Module DepOfNodep (Import M: S) <: Sdep with Module E := M.E.
Definition empty : {s : t | Empty s}.
Definition is_empty : forall s : t, {Empty s} + {~ Empty s}.
Definition mem : forall (x : elt) (s : t), {In x s} + {~ In x s}.
Definition Add (x : elt) (s s' : t) :=
forall y : elt, In y s' <-> E.eq x y \/ In y s.
Definition add : forall (x : elt) (s : t), {s' : t | Add x s s'}.
Definition singleton :
forall x : elt, {s : t | forall y : elt, In y s <-> E.eq x y}.
Definition remove :
forall (x : elt) (s : t),
{s' : t | forall y : elt, In y s' <-> ~ E.eq x y /\ In y s}.
Definition union :
forall s s' : t, {s'' : t | forall x : elt, In x s'' <-> In x s \/ In x s'}.
Definition inter :
forall s s' : t, {s'' : t | forall x : elt, In x s'' <-> In x s /\ In x s'}.
Definition diff :
forall s s' : t, {s'' : t | forall x : elt, In x s'' <-> In x s /\ ~ In x s'}.
Definition equal : forall s s' : t, {Equal s s'} + {~ Equal s s'}.
Definition subset : forall s s' : t, {Subset s s'} + {~Subset s s'}.
Definition elements :
forall s : t,
{l : list elt | sort E.lt l /\ (forall x : elt, In x s <-> InA E.eq x l)}.
Definition cardinal :
forall s : t,
{r : nat | let (l,_) := elements s in r = length l }.
Definition fdec (P : elt -> Prop) (Pdec : forall x : elt, {P x} + {~ P x})
(x : elt) := if Pdec x then true else false.
Hint Resolve compat_P_aux : core.
Definition filter :
forall (P : elt -> Prop) (Pdec : forall x : elt, {P x} + {~ P x}) (s : t),
{s' : t | compat_P E.eq P -> forall x : elt, In x s' <-> In x s /\ P x}.
Definition for_all :
forall (P : elt -> Prop) (Pdec : forall x : elt, {P x} + {~ P x}) (s : t),
{compat_P E.eq P -> For_all P s} + {compat_P E.eq P -> ~ For_all P s}.
Definition exists_ :
forall (P : elt -> Prop) (Pdec : forall x : elt, {P x} + {~ P x}) (s : t),
{compat_P E.eq P -> Exists P s} + {compat_P E.eq P -> ~ Exists P s}.
Definition partition :
forall (P : elt -> Prop) (Pdec : forall x : elt, {P x} + {~ P x}) (s : t),
{partition : t * t |
let (s1, s2) := partition in
compat_P E.eq P ->
For_all P s1 /\
For_all (fun x => ~ P x) s2 /\
(forall x : elt, In x s <-> In x s1 \/ In x s2)}.
Definition choose_aux: forall s : t,
{ x : elt | M.choose s = Some x } + { M.choose s = None }.
Definition choose : forall s : t, {x : elt | In x s} + {Empty s}.

Lemma choose_equal : forall s s', Equal s s' ->
match choose s, choose s' with
| inleft (exist _ x _), inleft (exist _ x' _) => E.eq x x'
| inright _, inright _  => True
| _, _                        => False
end.