Question

我目前正在尝试在Coq中实现Hilbert的几何。证明时，证明的一部分通常会重复多次；例如，在这里我试图证明存在3条彼此不同的线。

Proposition prop3_2 : (exists l m n: Line, (l<>m/\m<>n/\n<>l)).
Proof.
    destruct I3 as [A [B [C [[AneB [BneC CneA]] nAlgn]]]].
    destruct ((I1 A B) AneB) as [AB [incAB unAB]].
    destruct ((I1 B C) BneC) as [BC [incBC unBC]].
    destruct ((I1 C A) CneA) as [CA [incCA unCA]].

    refine (ex_intro _ AB _).
    refine (ex_intro _ BC _).
    refine (ex_intro _ CA _).
    split.
      (* Proving AB <> BC through contradiction *)
      case (classic (AB = BC)).
      intros AB_e_BC.
      rewrite AB_e_BC in incAB.
      pose (conj incBC (proj2 incAB)) as incABC.
      specialize (nAlgn BC).
      tauto.
      trivial.

      split.
        (* Proving BC <> CA through contradiction *)
        case (classic (BC = CA)).
        intros BC_e_CA.
        rewrite BC_e_CA in incBC.
        pose (conj incCA (proj2 incBC)) as incABC.
        specialize (nAlgn CA).
        tauto.
        trivial.

        (* Proving CA <> AB through contradiction *)
        case (classic (CA = AB)).
        intros CA_e_AB.
        rewrite CA_e_AB in incCA.
        pose (conj incAB (proj2 incCA)) as incABC.
        specialize (nAlgn AB).
        tauto.
        trivial.
Qed.

在这些情况下，如果有类似宏的代码，那将是非常好的。我考虑过要创建一个次证明：

Lemma prop3_2_a: (forall (A B C:Point) (AB BC:Line) 
    (incAB:(Inc B AB /\ Inc A AB)) (incBC:(Inc C BC /\ Inc B BC)) 
    (nAlgn : forall l : Line, ~ (Inc A l /\ Inc B l /\ Inc C l)), 
    AB <> BC).
Proof.
    ...

但这很麻烦，我必须创建三个不同版本的nAlgn，它们的顺序不同，这是可管理的，但很烦人。

代码可在此处找到：https://github.com/GiacomoMaletto/Hilbert/blob/master/hilbert.v

（顺便说一下，关于风格的任何其他评论或任何赞赏）。

Answer 1

首先，一些简单的建议可以分别重构这三种情况。

在每个项目的开头，目标如下：

...
--------------
AB <> BC

随后对(AB = BC)进行的案例分析有点多余。第一种情况(AB = BC)很有趣，您需要证明矛盾，而第二种情况(AB <> BC)则很琐碎。较短的方法是intro AB_e_BC，它只要求您证明第一种情况。之所以有效，是因为AB <> BC实际上是AB = BC -> False。

其他步骤大多是简单明了的命题推理，可以通过tauto进行暴力破解，除了需要重新编写代码并严格使用specialize。重写仅使用变量AB和BC之间的等式，在这种情况下，您可以使用subst速记，该速写使用所有等式进行重写，其中一侧是变量。所以这个片段：

  (* Proving AB <> BC through contradiction *)
  case (classic (AB = BC)).
  intros AB_e_BC.
  rewrite AB_e_BC in incAB.
  pose (conj incBC (proj2 incAB)) as incABC.
  specialize (nAlgn BC).
  tauto.
  trivial.

成为

  intro; specialize (nAlgnABC BC); subst; tauto.

现在您仍然不想写三遍。现在唯一变化的部分是变量BC。幸运的是，您可以在intro之前将其从目标中读出来。

--------------
AB <> BC
      ^----- there's BC (and in the other two cases, CA and AB)

实际上选择AB或BC都很好，因为intro假设它们相等。您可以使用match goal with通过从目标位置开始对战术进行参数化。

match goal with
| [ |- _ <> ?l ] => intro; specialize (nAlgnABC l); subst; tauto
end.

(* The syntax is:

   match goal with
   | [ |- ??? ] => tactics
   end.

   where ??? is an expression with wildcards (_) and existential
   variables (?l), that can be referred to inside the body "tactics"
   (without the question mark) *)

接下来，在拆分之前向上移动：

-------------------------------------------
AB <> BC /\ BC <> CA /\ CA <> AB

您可以制定策略来一次获得三个子目标：split; [| split].（意味着，分裂一次，然后在第二个子目标中再次分裂）。

最后，您想对每个子目标应用上面的match策略，这是另一个分号：

split; [| split];
  match goal with
  | [ |- _ <> ?l ] => intro; specialize (nAlgnABC l); subst; tauto
  end.

我还建议您使用项目符号和花括号来构造您的证明，以便在定义更改时，避免将混淆的证明状态输入，因为将策略应用于错误的子目标。以下是一些三例证明的可能布局：

split.
- ...
  ...

- split.
  + ...
    ...

  + ...
    ...


split; [| split].
- ...
  ...

- ...
  ...

- ...
  ...


split; [| split].
{ ...
  ...
}
{ ...
  ...
}
{ ...
  ...
}

避免在Coq中重复

1 个答案: