如何解决在Coq中使用模块的定义
以下代码指出，它在Coq中使用可扩展性公理定义了有限集：
(** A library for finite sets with extensional equality.
Author: Brian Aydemir. *)
Require Import FSets.
Require Import ListFacts.
Require Import Coq.Logic.ProofIrrelevance.
(* *********************************************************************** *)
(** * Interface *)
(** The following interface wraps the standard library's finite set
interface with an additional property: extensional equality. *)
Module Type S.
Declare Module E : UsualOrderedType.
Declare Module F : FSetInterface.S with Module E := E.
Parameter eq_if_Equal :
forall s s' : F.t,F.Equal s s' -> s = s'.
End S.
(* *********************************************************************** *)
(** * Implementation *)
(** For documentation purposes,we hide the implementation of a
functor implementing the above interface. We note only that the
implementation here assumes (as an axiom) that proof irrelevance
holds. *)
Module Make (X : UsualOrderedType) <: S with Module E := X.
(* begin hide *)
Module E := X.
Module F := FSetList.Make E.
Module OFacts := OrderedType.OrderedTypeFacts E.
Lemma eq_if_Equal :
forall s s' : F.t,F.Equal s s' -> s = s'.
Proof.
intros [s1 pf1] [s2 pf2] Eq.
assert (s1 = s2).
unfold F.MSet.Raw.t in *.
eapply Sort_InA_eq_ext; eauto.
intros; eapply E.lt_trans; eauto.
1 : {
apply F.MSet.Raw.isok_iff.
auto.
}
1 : {
apply F.MSet.Raw.isok_iff.
auto.
}
subst s1.
assert (pf1 = pf2).
apply proof_irrelevance.
subst pf2.
reflexivity.
Qed.
(* end hide *)
End Make.
如何使用此模块定义具有有限集签名的函数？
解决方法
您需要定义一个 Loop Until Not ech
' conversion of numbers into text for dico and listbox)
' and the false dates (written in text) to real dates
On Error GoTo PasDate
For i = 2 To UBound(t)
t(i,1) = CStr(t(i,1))
If TypeName(t(i,2)) = "String" Then t(i,2) = 1 * DateSerial(Right(t(i,2),4),Mid(t(i,4,Left(t(i,2))
Next i
On Error Resume Next
'Fill dico
Set dico = CreateObject("scripting.dictionary")
dico.CompareMode = TextCompare
For i = 2 To UBound(t)
If t(i,1) <> "" Then
If Not dico.Exists(t(i,1)) Then
dico.Add t(i,1),t(i,2)
Else
If t(i,2) > dico(t(i,1)) Then dico(t(i,1)) = t(i,2)
End If
End If
Next i
'Transfert dico to the table r for the list
ReDim r(1 To dico.Count,1 To 2): i = 0
For Each x In dico.Keys: i = i + 1: r(i,1) = x: r(i,2) = dico(x): Next
'fill ranges 20 and 21
.Range("b20:b21").Resize(,Columns.Count - 1).Clear
.Range("b20").Resize(1,UBound(r)).HorizontalAlignment = xlCenter
.Range("b21").Resize(1,UBound(r)).NumberFormat = "dd/mm/yyyy"
.Range("b20").Resize(2,UBound(r)).Borders.LineStyle = xlContinuous
.Range("b20:b21").Resize(2,UBound(r)) = Application.Transpose(r)
End With
'poplate the listbox
For i = 1 To UBound(r): r(i,1) = Format(r(i,"dd/mm/yyyy"): Next
'For i = 1 To UBound(r): r(i,"000"): r(i,2) = Format(r(i,"dd/mm/yyyy"): Next
With ListBox1
.ColumnCount = 2
.ColumnHeads = False
.ColumnWidths = .Width * 0.7 '& ";" & .Width * (1 - 0.6 + 0.1)
.List = r
End With
Exit Sub
'
PasDate:
Exit Sub
End
End Sub
模块（称为Module），该模块为您要制作有限集的类型实现M模块类型，然后构建另一个{{ 1}}和UsualOrderedType，其中包含您类型的有限集的实现。
Module请注意，您需要使用Make M而不是Module M <: UsualOrderedType.
...
End M.
Module foo := Make M.
Check foo.F.singleton.
来声明模块类型，否则您将隐藏以下事实：（在下面的示例中）为<:定义了模块不透明类型:后面。
假设您要制作nat的有限集合：
t现在您可以创建使用此有序类型的模块。
nat现在，我们可以使用我们的(* Print the module type to see all the things you need to define. *)
Print Module Type UsualOrderedType.
Require Import PeanonNat.
Module NatOrdered <: UsualOrderedType . (* note the `<:` *)
Definition t:=nat.
Definition eq:=@eq nat.
Definition lt:=lt.
Definition eq_refl:=@eq_refl nat.
Definition eq_sym:=@eq_sym nat.
Definition eq_trans:=@eq_trans nat.
Definition lt_trans:=Nat.lt_trans.
(* I wrote Admitted where I didn't provide an implementation *)
Definition lt_not_eq : forall x y : t,lt x y -> ~ eq x y. Admitted.
Definition compare : forall x y : t,Compare lt eq x y. Admitted.
Definition eq_dec : forall x y : t,{eq x y} + {~ eq x y}. Admitted.
End NatOrdered.
模块。有限集的类型为Module foo := Make NatOrdered.
Print foo.F. (* to see everything that is defined for the FSetList *)
Import foo. (* get F in our namespace so we can say F.t instead of foo.F.t,etc. *)
，元素的类型为F，它们可以强制F.t，因为我们知道它们来自F.elt。
让我们构建一个使用nat中内容的函数。
NatOrdered好的。由于我没有实现上面的F，因此在计算中途陷入困境。我很懒，只是写了Definition f: F.elt -> F.t.
intros x. apply (F.singleton x).
Defined.
Print F.
Goal F.cardinal (F.union (f 1) (f 2)) = 2.
compute.
，但是你可以做到的！ ：-）
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。