Question

我正在研究IndProp.v的Software Foundations (Vol 1: Logical Foundations)中以下定理Sn_le_Sm__n_le_m的证明。

Theorem Sn_le_Sm__n_le_m : ∀n m,
  S n ≤ S m → n ≤ m.
Proof.
  intros n m HS.
  induction HS as [ | m' Hm' IHm'].
  - (* le_n *) (* Failed Here *)
  - (* le_S *) apply IHSm'.
Admitted.

其中le (i.e., ≤)的定义是：

Inductive le : nat → nat → Prop :=
  | le_n n : le n n
  | le_S n m (H : le n m) : le n (S m).
Notation "m ≤ n" := (le m n).

在induction HS之前，上下文和目标如下：

n, m : nat
HS : S n <= S m
______________________________________(1/1)
n <= m

在第一个项目符号-处，上下文以及目标是：

n, m : nat
______________________________________(1/1)
n <= m

我们必须在没有任何上下文的情况下证明n <= m，这显然是不可能的。

为什么在S n = S m的{{1}}情况下，它不会生成n = m（然后是le_n）？

Answer 1

这里的主要问题-我认为-无法在HS上使用归纳法来证明定理，因为仅凭n的假设就无法说出S n因为没有le的构造函数不会更改n的值。但是无论如何，在第一个项目符号-之后没有假设的原因是，调用induction的作用是用与每个构造函数相对应的值替换所有出现的property参数，但这没有帮助。在这种情况下，因为替换S n一词在任何地方都没有提及。有一些技巧可以避免这种情况。例如，您可以按以下方式用pred(S n)替换n。

Theorem Sn_le_Sm__n_le_m : forall n m,
  S n <= S m -> n <= m.
Proof.
  intros n m HS.
  assert(Hn: n=pred (S n)). reflexivity. rewrite Hn.
  assert(Hm: m=pred (S m)). reflexivity. rewrite Hm.
  induction HS.
  - (* le_n *) apply le_n.
  - (* le_S *) (* Stucks! *) Abort.

但是如上所述，这是不可能的。另一种方法是使用更智能的inversion，但在某些情况下可能无济于事，因为归纳假设是必要的。但是值得了解。

Theorem Sn_le_Sm__n_le_m : forall n m,
  S n <= S m -> n <= m.
Proof.
  intros n m HS.
  inversion HS.
  - (* le_n *) apply le_n.
  - (* le_S *) (* Stucks! *) Abort.

解决问题的最佳方法是使用remember策略，如下所示。

Theorem Sn_le_Sm__n_le_m : forall n m,
  S n <= S m -> n <= m.
Proof.
  intros n m HS.
  remember (S n) as Sn.
  remember (S m) as Sm.
  induction HS as [ n' | n' m' H IH].
  - (* le_n *)
    rewrite HeqSn in HeqSm. injection HeqSm as Heq.
    rewrite <- Heq. apply le_n.
  - (* le_S *) (* Stucks! *) Abort.

根据Software Foundations (Vol 1: Logical Foundations)

策略remember e as x使Coq（1）替换所有出现的情况由变量x表示表达式e，并且（2）添加一个方程x = e 到上下文。

无论如何，尽管无法证明在HS -imo-上使用归纳法，但对m进行归纳法将解决问题。（请注意使用inversion。）

Theorem Sn_le_Sm__n_le_m : forall n m,
  S n <= S m -> n <= m.
Proof.
  intros n.
  induction m as [|m' IHm'].
  - intros H. inversion H as [Hn | n' contra Hn'].
    + apply le_n.
    + inversion contra.
  - intros H. inversion H as [HnSm' | n' HSnSm' Heq].
    + apply le_n.
    + apply le_S. apply IHm'. apply HSnSm'.
Qed.

Answer 2

仅是Kamyar答案的更多示例。好吧，让我们看一下le归纳方案：

Compute le_ind.

forall (n : nat) (P : nat -> Prop),
       P n ->
       (forall m : nat, n <= m -> P m -> P (S m)) ->
       forall n0 : nat, n <= n0 -> P n0

P是一个拥有一个自然数的命题，这意味着在le_n的情况下，我们的介词n <= m将减少为所有n，n <= m。确实，这是我们要证明的引理，但是由于没有前提而无法证明。

一个简单的解决方法是在le_ind不执行的情况下进行归纳。

例如：

Theorem Sn_le_Sm__n_le_m' : forall m n,
  S n <= S m -> n <= m.
 elim.
 by intros; apply : Gt.gt_S_le .
 intros; inversion H0.
 by subst.
 by subst; apply : le_Sn_le.
Qed.

请注意，我们通过m进行归纳，并使用反演生成le的两种可能的构造（{x = y} + {x

Theorem Sn_le_Sm__n_le_m : forall n m,
  S n <= S m -> n <= m.
  intros.
  generalize dependent n.
  elim.
  auto with arith.
  intros.
    have : n <= m.
    by apply : H; apply : le_Sn_le.
  move => H'.
  destruct m.
  auto with arith.
  destruct (le_lt_eq_dec _ _ H').
  assumption.
  subst.
  (* just prove that there is no S m <= m *) 
Qed.

为了您的时间方便，coq具有与策略有关的归纳方法，可以轻松解决您的目标：

Theorem Sn_le_Sm__n_le_m'' : forall n m,
  S n <= S m -> n <= m.
 intros.
 dependent induction H.
 auto.
 by apply : (le_Sn_le _ _ H).
Qed.

推导Coq中“小于”关系的证据

2 个答案: