## A.7 library(clpb): Constraint Logic Programming over Boolean Variables

author
  Markus Triska

#### A.7.1 Introduction

Constraint programming is a declarative formalism that lets you state relations between terms. This library provides CLP(B), Constraint Logic Programming over Boolean Variables. It can be used to model and solve combinatorial problems such as verification, allocation and covering tasks.

The implementation is based on reduced and ordered Binary Decision Diagrams (BDDs).

#### A.7.2 Boolean expressions

A Boolean expression is one of:

> `0` | false
> `1` | true
> variable | unknown truth value
> `~` Expr | logical NOT
> Expr + Expr | logical OR
> Expr * Expr | logical AND
> Expr # Expr | exclusive OR
> Var `^` Expr | existential quantification
> Expr `=:=` Expr | equality
> Expr `=\=` Expr | disequality (same as #)
> Expr `=<` Expr | less or equal (implication)
> Expr `>=` Expr | greater or equal
> Expr < Expr | less than
> Expr > Expr | greater than
> `card(Is,Exprs)` | see below
> `+(Exprs)` | see below
> `*(Exprs)` | see below

where Expr again denotes a Boolean expression.

The Boolean expression `card(Is,Exprs)` is true iff the number of true expressions in the list Exprs is a member of the list Is of integers and integer ranges of the form `From-To`.

`+(Exprs)` and `*(Exprs)` denote, respectively, the disjunction and conjunction of all elements in the list Exprs of Boolean expressions.

#### A.7.3 Interface predicates

Important interface predicates of CLP(B) are:

sat(+Expr)
  True iff the Boolean expression Expr is satisfiable.
taut(+Expr, -T)
  If Expr is a tautology with respect to the posted constraints, succeeds with T = 1. If Expr cannot be satisfied, succeeds with T = 0. Otherwise, it fails.
labeling(+Vs)
  Assigns truth values to the variables Vs such that all constraints are satisfied.

The unification of a CLP(B) variable X with a term T is equivalent to posting the constraint `sat(X=:=T)`.

#### A.7.4 Examples

Here is an example session with a few queries and their answers:

    ?- use_module(library(clpb)).
    true.

    ?- sat(X*Y).
    X = Y, Y = 1.

    ?- sat(X * ~X).
    false.

    ?- taut(X * ~X, T).
    T = 0,
    sat(X=:=X).

    ?- sat(X^Y^(X+Y)).
    sat(X=:=X),
    sat(Y=:=Y).

    ?- sat(X*Y + X*Z), labeling([X,Y,Z]).
    X = Z, Z = 1, Y = 0 ;
    X = Y, Y = 1, Z = 0 ;
    X = Y, Y = Z, Z = 1.

    ?- sat(X =< Y), sat(Y =< Z), taut(X =< Z, T).
    T = 1,
    sat(1#X#X*Y),
    sat(1#Y#Y*Z).

The pending residual goals constrain remaining variables to Boolean expressions and are declaratively equivalent to the original query.

[semidet]sat(+Expr)
  True iff Expr is a satisfiable Boolean expression.
[semidet]taut(+Expr, -T)
  Succeeds with T = 0 if the Boolean expression Expr cannot be satisfied, and with T = 1 if Expr is always true with respect to the current constraints. Fails otherwise.
[multi]labeling(+Vs)
  Assigns truth values to the Boolean variables Vs such that all stated constraints are satisfied.
[det]sat_count(+Expr, -N)
  N is the number of different assignments of truth values to the variables in the Boolean expression Expr, such that Expr is true and all posted constraints are satisfiable.

  Example:

      ?- length(Vs, 120), sat_count(+Vs, CountOr), sat_count(*(Vs), CountAnd).
      Vs = [...],
      CountOr = 1329227995784915872903807060280344575,
      CountAnd = 1.