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

onto nfalse if a(nvar) = 0, otherwise a(nvar) = 1 and we move onto ntrue. If we reach the
0 node then f(a) = 0, otherwise we reach the 1 node and f(a) = 1. The semantics,
according to [BS98], can be formally defined by a function which maps each ROBDD into
the represented Boolean function:
Definition 6. (Semantics of ROBDDs.) The function ·D : D → F is given, for each
(r, N) ∈ D, by
⎧
⎪⎨ ⊥, if r = 0;
def
(r, N) = ⊤,
D
if r = 1;
⎪⎩ rvar ∧ (rtrue, Ntrue)
∨ ¬rvar ∧ (rfalse, Nfalse)
, otherwise.
D
For the sake of simplicity, we will sometimes write (r) D instead of (r, N) D.
2.2 ROBDD properties
2.2.1 Canonicity
Theorem 2. (Canonicity of ROBDDs.) Given a fixed variable ordering ≺, we have
that for each f ∈ F there exists one and only one ROBDD (r, N) ∈ D such that
(r, N) D = f.
Proof. See [Bry86].
This has many important consequences for the CORAL implementation: for example,
we have that two Boolean functions are identical if and only if they are represented by
the same ROBDD. CORAL keeps only one copy of each ROBDD into memory, so that
equality test on ROBDDs can be performed simply by comparing their memory addresses.
2.2.2 Influence of variable ordering
The number of nodes of ROBDDs is extremely critical for the efficiency of the algorithms
used to manipulate them, and the size of the ROBDD which represents a particular
Boolean function may vary depending on the chosen variable ordering. Unfortunately, for
any fixed variable ordering, it is possible to find some Boolean functions such that their
representative ROBDD’s size is exponential in the number of variables. For example,
Bryant has verified in [Bry92] that while ROBDDs for symmetric Boolean functions may
have sizes that range from being linear to quadratic in the number of variables depending
on the chosen ordering, yet ROBDDs for functions representing integer addition may range
from linear to exponential; for integer multiplication we even have exponentiality for all
variable orderings. This is why some ROBDD implementations have built-in mechanisms
for changing variable ordering dynamically, relying for example on heuristical analysis.
CORAL instead uses fixed variablable ordering and relies on other mechanisms (which
will be discussed later) for the purpose of keeping the ROBDDs as small as possible. In
Figure 2.2 we give an example of two ROBDDs representing the same Boolean function
(x1 ∧ y1) ∨ (x2 ∧ y2) ∨ (x3 ∧ y3) using two different variable orderings.
2.2 ROBDD properties 7
D