How to define set in coq without defining set as a list of elements

Question

I am trying to define (1,2,3) as a set of elements in coq. I can define it using list as (1 :: (2 :: (3 :: nil))). Is there any way to define set in coq without using list.

Answer 1

The standard library of coq provides the following finite set modules:

1. Coq.MSets abstracts away the implementation details of the set. For instance, there is an implementation that uses AVL trees and another based on lists.
2. Coq.FSets abstracts away the implementation details of the set; it is a previous version of MSets.
3. Coq.Lists.ListSet is an encoding of lists as sets, which I am including for the sake of completeness

Here is an example on how to define a set with FSets:

Require Import Coq.Structures.OrderedTypeEx.
Require Import Coq.FSets.FSetAVL.

Module NSet := FSetAVL.Make Nat_as_OT.
(* Creates a set with only element 3 inside: *)
Check (NSet.add 3 NSet.empty).

Answer 2

There are many encodings of sets in Coq (lists, function, trees, ...) which can be finite or not. You should have a look at Coq's standard library. For example the 'simplest' set definition I know is this one

Answer 3

The are basically four possible choices to be made when defining sets in Coq depending on your constraints on the base type of the set and computation needs:

• If the base type doesn't have decidable equality, it is common to use:

  Definition Set A := A -> Prop
  Definition cup A B := fun x => A x /\ B x.
  ...
  

  basically, Coq's Ensembles. This representation cannot "compute", as we can't even decide if two elements are equal.

• If the base data type has decidable equality, then there are two choices depending if extensionality is wanted:

  • Extensionality means that two sets are equal in Coq's logic iff they have the same elements, formally:

    forall (A B : set T), (A = B) <-> (forall x, x \in A <-> x \in B).
    

    If extensionality is wanted, sets should be represented by a canonically-sorted duplicate-free structure, usually a list. A good example is Cyril's Cohen finmap library. This representation however is very inefficient for computing as re-sorting is needed every time a set is modified.

  • If extensionality is not needed (usually a bad idea if proofs are wanted), you can use representations based on binary trees such as Coq's MSet, which are similar to standard Functional Programming set implementations and can work efficiently.

• Finally, when the base type is finite, the set of all sets is a finite type too. The best example of this approach is IMO math-comp's finset, which encodes finite sets as the space of finitely supported membership functions, which is extensional, and forms a complete lattice.