a modern C++ library for the manipulation of Boolean functions

3 Algorithms in CORAL
3.1 Basic data structures
3.1.1 Sets of Boolean variables
The type of variable indexes is index_type. A single Boolean variable in CORAL is
represented by an object of class Variable; it is a very simple class whose objects can
be built using a constructor that takes an index_type which represents the index of
the variable. To represent (finite) sets of variables we use the Bit_Set class, which in
turn represents a set using a bitmap as its private data member: a specific variable vi
is contained in the set if and only if the bit in the position i of the bitmap exists and
is set to 1. The type of this bitmap is mpz_t, which is provided by the GMP library;
using bitmaps allows us to implement the common operations on sets such as union,
intersection, difference and inclusion tests efficiently. The end user in fact utilizes class
Variables_Set instead, which is a simple wrapper for Bit_Set that is a bit closer to
the concept of variable.
3.1.2 Equivalence relations
An object of class Equivalence_Relation represents an equivalence relation L ∈ L.
The internal representation consists of a vector of elements of type index_type. Each
element of the vector in position i is set to value l if vl is the leader of vi for the relation,
or to the special value NOT_IN_DOMAIN if vi /∈ dom(L). CORAL provides some functions
to perform basic computations on Boolean function such as the intersection ∨ and the
transitive closure of the union ∧.
3.1.3 Hash table
An hash table hash_table is used to ensure that there are no duplicate ROBDD nodes,
as described in Subsection 2.3.1. Its method find_or_insert performs a lookup taking
the three components of the key (the variable by which the root of the ROBDD is labeled,
a pointer to the true successor and a pointer to the false successor) as its arguments: if
an entry is found then the the return value is a pointer to the ROBDD that has already
been constructed, otherwise a new node is allocated, a cache entry for it is added and the
return value is a pointer to this new node. This method also handles the particular case
where the two pointer arguments are in fact the same pointer simply by returning this
pointer, in order to respect the third reduction rule. The static method make_node of
class ROBDD is simply a wrapper for find_or_insert that takes the same arguments
and returns the same pointer. From now on, whenever we are describing a ROBDD