Question

我正在撰写一篇关于使用Coq系统进行快速排序算法程序验证的论文。我已经在Coq中定义了一个快速排序，但我的主管和我自己并不习惯使用策略编写实际证据。有没有人可以帮助这部分的coq证明？以下是我们迄今为止提出的建议：

Inductive nat : Type :=
   | O : nat
   | S : nat -> nat.

Check (S (S (S (S O)))).

Definition isZero (n:nat) : bool :=
  match n with
   O => true
   |S p => false
  end.

Inductive List: Set :=
 | nil: List
 | cons: nat -> List -> List.

Fixpoint Concat (L R: List) : List :=
 match L with
 | nil => R
 | cons l ls => cons l (Concat ls R)
end.  

Fixpoint Less (n m:nat) :=
  match m with
   O => false
  |S q => match n with
          O => true
         |S p => Less p q
         end
  end.      

Fixpoint Lesseq (n m:nat) :=
  match n with
   O => true
  |S p => match m with
           O => false
          |S q => Lesseq p q
          end
  end.

Fixpoint Greatereq (n m:nat) :=
  match n with
   O => true
  |S p => match m with
           O => true
          |S q => Greatereq p q
          end
  end.


Fixpoint Allless (l:List) (n:nat) : List :=
  match l with
   nil => nil
  |cons m ls => match Less n m with
                 false => Allless ls n
                |true => cons m (Allless ls n)
                end
end.               

Fixpoint Allgeq (l:List) (n:nat) : List :=
  match l with
   nil => nil
  |cons m ls => match Greatereq n m with
                 false => Allgeq ls n
                |true => cons m (Allgeq ls n)
                end
end.  

Fixpoint qaux (n:nat) (l:List) : List := 
  match n with
  O => nil
 |S p => match l with
         nil => nil
        |cons m ls => let low := Allless ls m in
                     (let high := Allgeq ls m in 
                     Concat (qaux p low) (cons m (qaux p high)))
        end
 end.

Fixpoint length (l:List) : nat :=
 match l with
  nil => O
|cons m ls => S (length ls)
end.

Fixpoint Quicksort (l:List) : List := qaux (length l) l.

我知道要工作的证明我们需要一个引理或一个定理，但后来我不知道从那里开始。谢谢你的帮助：）

Answer 1

你可以证明你的代码很多很好的定理。

定义一个函数pos，它将数字和列表映射到列表中数字的索引。
Th 1：对于S中的所有列表S和a，b，（a＆lt; = b）＆lt; - ＆gt; （pos a（sort S））＆lt; =（pos b（sort S））。这将是sort函数的正确性定理。
Th 2 :(排序（排序S））=排序S
定义函数min和max以查找列表S的最小和最大元素。
Th 3：排序列表中最小元素的位置为0.
Th 4：排序列表反向最大元素的pos为0.

从您的排序例程中抽象出一个谓词，以便您可以将其作为参数传递。

Th 5：显示（sort＆lt; = S）=（反向（sort＆gt; = S））

等。您可以无限制地继续此广告。这很有趣。： - ）

Answer 2

将您的问题视为“符号测试”的问题。编写一个测试输出正确的函数，然后显示初始代码和测试函数的所有组合都按预期工作。

这是我最喜欢的数据类型排序算法的测试函数。

Fixpoint sorted (l : List) : bool :=
  match l with cons a l' =>
    match l' with cons b l'' =>
      if Lesseq a b then sorted l' else false
    | nil => true
    end
  | nil => true
  end.

然后您可以通过以下方式开始证明：

Lemma Quicksort_sorted : forall l, sorted (Quicksort l) = true.

但在证明主要证据之前，你必须证明许多中间的引理。因此，正式证明非常类似于测试，除非您确保完全覆盖测试。

使用Coq的Quicksort证明

2 个答案: