SWI-Prolog 5.6.59 Reference Manual: Section A.7

## A.7 clpfd.pl -- Constraint Logic Programming over Finite Domains

author
  Markus Triska

Constraint programming is a declarative formalism that lets you describe conditions a solution must satisfy. This library provides CLP(FD), Constraint Logic Programming over Finite Domains. It can be used to model and solve various combinatorial problems such as planning, scheduling and allocation tasks.

Most predicates of this library are finite domain constraints, which are relations over integers. They generalise arithmetic evaluation of integer expressions in that propagation can proceed in all directions. This library also provides enumeration predicates, which let you systematically search for solutions on variables whose domains have become finite. A finite domain expression is one of:

> an integer | Given value
> a variable | Unknown value
> -Expr | Unary minus
> Expr + Expr | Addition
> Expr * Expr | Multiplication
> Expr - Expr | Subtraction
> min(Expr,Expr) | Minimum of two expressions
> max(Expr,Expr) | Maximum of two expressions
> Expr mod Expr | Remainder of integer division
> abs(Expr) | Absolute value
> Expr / Expr | Integer division

The most important finite domain constraints are:

> Expr1 `#>=` Expr2 | Expr1 is larger than or equal to Expr2
> Expr1 `#=<` Expr2 | Expr1 is smaller than or equal to Expr2
> Expr1 `#=` Expr2 | Expr1 equals Expr2
> Expr1 `#\=` Expr2 | Expr1 is not equal to Expr2
> Expr1 `#>` Expr2 | Expr1 is strictly larger than Expr2
> Expr1 `#<` Expr2 | Expr1 is strictly smaller than Expr2

The constraints in/2, #=/2, #\=/2, #</2, #>/2, #=</2, and #>=/2 can be reified, which means reflecting their truth values into Boolean values represented by the integers 0 and 1. Let P and Q denote reifiable constraints or Boolean variables, then:

> `#\` Q | True iff Q is false
> P `#\/` Q | True iff either P or Q
> P `#/\` Q | True iff both P and Q
> P `#<==>` Q | True iff P and Q are equivalent
> P `#==>` Q | True iff P implies Q
> P `#<==` Q | True iff Q implies P

The constraints of this table are reifiable as well. If a variable occurs at the place of a constraint that is being reified, it is implicitly constrained to the Boolean values 0 and 1. Therefore, the following queries all fail: `?-` `#\` 2., `?-` `#\` `#\` 2. etc.

A common usage of this library is to first post the desired constraints among the variables of a model, and then to use enumeration predicates to search for solutions. As an example of a constraint satisfaction problem, consider the cryptoarithmetic puzzle SEND + MORE = MONEY, where different letters denote distinct integers between 0 and 9. It can be modeled in CLP(FD) as follows:

    :- use_module(library(clpfd)).

    puzzle([S,E,N,D] + [M,O,R,E] = [M,O,N,E,Y]) :-
            Vars = [S,E,N,D,M,O,R,Y],
            Vars ins 0..9,
            all_different(Vars),
                      S*1000 + E*100 + N*10 + D +
                      M*1000 + O*100 + R*10 + E #=
            M*10000 + O*1000 + N*100 + E*10 + Y,
            M #\= 0, S #\= 0.

Sample query and its result:

    ?- puzzle(As+Bs=Cs).
    As = [9, _G10107, _G10110, _G10113],
    Bs = [1, 0, _G10128, _G10107],
    Cs = [1, 0, _G10110, _G10107, _G10152],
    _G10107 in 4..7,
    1000*9+91*_G10107+ -90*_G10110+_G10113+ -9000*1+ -900*0+10*_G10128+ -1*_G10152#=0,
    all_different([_G10107, _G10110, _G10113, _G10128, _G10152, 0, 1, 9]),
    _G10110 in 5..8,
    _G10113 in 2..8,
    _G10128 in 2..8,
    _G10152 in 2..8.

Here, the constraint solver has deduced more stringent bounds for all variables. Keeping the modeling part separate from the search allows to view these residual goals, observe termination and determinism properties of the modeling part in isolation from the search, and to more easily experiment with different search strategies. Labeling can then be used to search for solutions:

    ?- puzzle(As+Bs=Cs), label(As).
    As = [9, 5, 6, 7],
    Bs = [1, 0, 8, 5],
    Cs = [1, 0, 6, 5, 2] ;
    false.

In this case, it suffices to label a subset of variables to find the puzzle's unique solution, since the constraint solver is strong enough to reduce the domains of remaining variables to singleton sets. In general though, it is necessary to label all variables to obtain ground solutions.

It is perfectly reasonable to use CLP(FD) constraints instead of ordinary integer arithmetic with is/2, >/2 etc. For example:

    :- use_module(library(clpfd)).

    fac(0, 1).
    fac(N, F) :- N #> 0, N1 #= N - 1, F #= N * F1, fac(N1, F1).

This predicate can be used in all directions. For example:

    ?- fac(47, F).
    F = 258623241511168180642964355153611979969197632389120000000000 ;
    false.

    ?- fac(N, 1).
    N = 0 ;
    N = 1 ;
    false.

    ?- fac(N, 3).
    false.

To make the predicate terminate if any argument is instantiated, add the (implied) constraint F `#\=` 0 before the recursive call. Otherwise, the query fac(N, 0) is the only non-terminating case of this kind.

This library uses goal_expansion/2 to rewrite constraints at compilation time. The expansion's aim is to transparently bring the performance of CLP(FD) constraints close to that of conventional arithmetic predicates (</2, =:=/2, is/2 etc.) when the constraints are used in modes that can also be handled by built-in arithmetic. To disable the expansion, set the flag clpfd_goal_expansion to false.

Use call_residue_vars/2 and copy_term/3 to inspect residual goals and the constraints in which a variable is involved. This library also provides reflection predicates (like fd_dom/2, fd_size/2 etc.) with which you can inspect a variable's current domain. These predicates can be useful if you want to implement your own labeling strategies.

You can also define custom constraints. The mechanism to do this is not yet finalised, and we welcome suggestions and descriptions of use cases that are important to you. As an example of how it can be done currently, let us define a new custom constraint "oneground(X,Y,Z)", where Z shall be 1 if at least one of X and Y is instantiated:

    :- use_module(library(clpfd)).

    :- multifile clpfd:run_propagator/2.

    oneground(X, Y, Z) :-
            clpfd:make_propagator(oneground(X, Y, Z), Prop),
            clpfd:init_propagator(X, Prop),
            clpfd:init_propagator(Y, Prop),
            clpfd:trigger_once(Prop).

    clpfd:run_propagator(oneground(X, Y, Z), MState) :-
            (   integer(X) -> clpfd:kill(MState), Z = 1
            ;   integer(Y) -> clpfd:kill(MState), Z = 1
            ;   true
            ).

First, clpfd:make_propagator/2 is used to transform a user-defined representation of the new constraint to an internal form. With clpfd:init_propagator/2, this internal form is then attached to X and Y. From now on, the propagator will be invoked whenever the domains of X or Y are changed. Then, clpfd:trigger_once/1 is used to give the propagator its first chance for propagation even though the variables' domains have not yet changed. Finally, clpfd:run_propagator/2 is extended to define the actual propagator. As explained, this predicate is automatically called by the constraint solver. The first argument is the user-defined representation of the constraint as used in clpfd:make_propagator/2, and the second argument is a mutable state that can be used to prevent further invocations of the propagator when the constraint has become entailed, by using clpfd:kill/1. An example of using the new constraint:

    ?- oneground(X, Y, Z), Y = 5.
    Y = 5,
    Z = 1,
    X in inf..sup.

?Var in +Domain
  Var is an element of Domain. Domain is one of:
  Integer
    Singleton set consisting only of Integer.
  Lower .. Upper
    All integers I such that Lower `=<` I `=<` Upper. Lower must be an integer or the atom inf, which denotes negative infinity. Upper must be an integer or the atom sup, which denotes positive infinity.
  Domain1 `\/` Domain2
    The union of Domain1 and Domain2.
+Vars ins +Domain
  The variables in the list Vars are elements of Domain.
indomain(?Var)
  Bind Var to all feasible values of its domain on backtracking. The domain of Var must be finite.
label(+Vars)
  Equivalent to labeling([], Vars).
labeling(+Options, +Vars)
  Labeling means systematically trying out values for the finite domain variables Vars until all of them are ground. The domain of each variable in Vars must be finite. Options is a list of options that let you exhibit some control over the search process. Several categories of options exist:

  The variable selection strategy lets you specify which variable of Vars should be labeled next and is one of:

  leftmost
    Label the variables in the order they occur in Vars. This is the default.
  ff
    First fail. Label the leftmost variable with smallest domain next, in order to detect infeasibility early. This is often a good strategy.
  ffc
    Of the variables with smallest domains, the leftmost one participating in most constraints is labeled next.
  min
    Label the leftmost variable whose lower bound is the lowest next.
  max
    Label the leftmost variable whose upper bound is the highest next.

  The value order is one of:

  up
    Try the elements of the chosen variable's domain in ascending order. This is the default.
  down
    Try the domain elements in descending order.

  The branching strategy is one of:

  step
    For each variable X, a choice is made between X = V and X `#\=` V, where V is determined by the value ordering options. This is the default.
  enum
    For each variable X, a choice is made between X = V_1, X = V_2 etc., for all values V_i of the domain of X. The order is determined by the value ordering options.
  bisect
    For each variable X, a choice is made between X `#=<` M and X `#>` M, where M is the midpoint of the domain of X.

  At most one option of each category can be specified, and an option must not occur repeatedly.

  The order of solutions can be influenced with:

  min(Expr)
  max(Expr)

  This generates solutions in ascending/descending order with respect to the evaluation of the arithmetic expression Expr. Labeling Vars must make Expr ground. If several such options are specified, they are interpreted from left to right, e.g.:

      ?- [X,Y] ins 10..20, labeling([max(X),min(Y)],[X,Y]).

  This generates solutions in descending order of X, and for each binding of X, solutions are generated in ascending order of Y. To obtain the incomplete behaviour that other systems exhibit with "maximize(Expr)" and "minimize(Expr)", use once/1, e.g.:

      once(labeling([max(Expr)], Vars))

  Labeling is always complete, always terminates, and yields no redundant solutions.

all_different(+Vars)
  Vars are pairwise distinct.
sum(+Vars, +Rel, +Expr)
  The sum of elements of the list Vars is in relation Rel to Expr. For example:

      ?- [A,B,C] ins 0..sup, sum([A,B,C], #=, 100).
      A in 0..100,
      A+B+C#=100,
      B in 0..100,
      C in 0..100.

?X #>= ?Y
  X is greater than or equal to Y.
?X #=< ?Y
  X is less than or equal to Y.
?X #= ?Y
  X equals Y.
?X #\= ?Y
  X is not Y.
?X #> ?Y
  X is greater than Y.
?X #< ?Y
  X is less than Y. In addition to its regular use in problems that require it, this constraint can also be useful to eliminate uninteresting symmetries from a problem. For example, all possible matches between pairs built from four players in total:

      ?- Vs = [A,B,C,D], Vs ins 1..4, all_different(Vs), A #< B, C #< D, A #< C,
         findall(pair(A,B)-pair(C,D), label(Vs), Ms).
      Ms = [pair(1, 2)-pair(3, 4), pair(1, 3)-pair(2, 4), pair(1, 4)-pair(2, 3)]

#\ +Q
  The reifiable constraint Q does not hold. For example, to obtain the complement of a domain:

      ?- #\ X in -3..0\/10..80.
      X in inf.. -4\/1..9\/81..sup.

?P #<==> ?Q
  P and Q are equivalent. For example:

      ?- X #= 4 #<==> B, X #\= 4.
      B = 0,
      X in inf..3\/5..sup.

?P #==> ?Q
  P implies Q.
?P #<== ?Q
  Q implies P.
?P #/\ ?Q
  P and Q hold.
?P #\/ ?Q
  P or Q holds. For example, the sum of natural numbers below 1000 that are multiples of 3 or 5:

      ?- N mod 3 #= 0 #\/ N mod 5 #= 0, N in 0..999, findall(N, indomain(N), Ns), sum(Ns, #=, Sum).
      Ns = [0, 3, 5, 6, 9, 10, 12, 15, 18|...],
      Sum = 233168

lex_chain(+Lists)
  Lists are lexicographically non-decreasing.
tuples_in(+Tuples, +Relation)
  Relation must be a list of lists of integers. The elements of the list Tuples are constrained to be elements of Relation. Arbitrary finite relations, such as compatibility tables, can be modeled in this way. For example, if 1 is compatible with 2 and 5, and 4 is compatible with 0 and 3:

      ?- tuples_in([[X,Y]], [[1,2],[1,5],[4,0],[4,3]]), X = 4.
      X = 4,
      Y in 0\/3.

  As another example, consider a train schedule represented as a list of quadruples, denoting departure and arrival places and times for each train. In the following program, Ps is a feasible journey of length 3 from A to D via trains that are part of the given schedule.

      :- use_module(library(clpfd)).

      trains([[1,2,0,1],[2,3,4,5],[2,3,0,1],[3,4,5,6],[3,4,2,3],[3,4,8,9]]).

      threepath(A, D, Ps) :-
              Ps = [[A,B,_T0,T1],[B,C,T2,T3],[C,D,T4,_T5]],
              T2 #> T1,
              T4 #> T3,
              trains(Ts),
              tuples_in(Ps, Ts).

  In this example, the unique solution is found without labeling:

      ?- threepath(1, 4, Ps).
      Ps = [[1, 2, 0, 1], [2, 3, 4, 5], [3, 4, 8, 9]].

all_distinct(+Ls)
  Like all_different/1, with stronger propagation.
serialized(+Starts, +Durations)
  Constrain a set of intervals to a non-overlapping sequence. Starts = [S_1,...,S_n], is a list of variables or integers, Durations = [D_1,...,D_n] is a list of non-negative integers. Constrains Starts and Durations to denote a set of non-overlapping tasks, i.e.: S_i + D_i `=<` S_j or S_j + D_j `=<` S_i for all 1 `=<` i < j `=<` n.
  See also
    Dorndorf et al. 2000, "Constraint Propagation Techniques for the Disjunctive Scheduling Problem"
element(?N, +Is, ?I)
  The N-th element of the list of integers Is is I. Analogous to nth1/3.
zcompare(?Order, ?A, ?B)
  Analogous to compare/3, with finite domain variables A and B. Example:

       fac(N, F) :-
               zcompare(C, N, 0),
               fac_(C, N, F).

       fac_(=, _, 1).
       fac_(>, N, F) :- F #= F0*N, N1 #= N - 1, fac(N1, F0).

  This version is deterministic if the first argument is instantiated:

      ?- fac(30, F).
      F = 265252859812191058636308480000000.

fd_var(+Var)
  True iff Var is a CLP(FD) variable.
fd_inf(+Var, -Inf)
  Inf is the infimum of the current domain of Var.
fd_sup(+Var, -Sup)
  Sup is the supremum of the current domain of Var.
fd_size(+Var, -Size)
  Size is the number of elements of the current domain of Var, or the atom sup if the domain is unbounded.
fd_dom(+Var, -Dom)
  Dom is the current domain (see in/2) of Var. This predicate is useful if you want to reason about domains. It is not needed if you only want to display remaining domains; instead, separate your model from the search part and let the toplevel display this information via residual goals.