This program provides new labeling functions:

fd_labeling_sbds(+L,+Sym).
fd_labeling_sbds(+L,+Sym,+Options).


1-Description:

L is the list of variables.
Sym is the list of symmetries using predicates sym/2, sym/3 and group/1.
sym/2 and sym/3 are facts describing the symmetries using list(s)
of permutation over variables, values or couples variable/value (called a point).
group/1 is a predicate which generates all symmetry predicates from
a list of symmetry generators. The order of variable in L must be the same as the order chosen for
specify the symmetries.
Options is the list of labeling methods (like gprolog).


2-Specify symmetries:

The specification of symmetries is very simple and several methods exist. For help we will take the example
of n-queens, with n=4. L is a list of four variables representing each row of the board,
each variable has a domain from 1 to 4, for each line (note that 0 is added for specify symmetries).
There are eight obvious geometric symmetries (with the identity but which doesn't be specified).

sym(point,LPoint):

 In the general case each (variable,value) couple is converted in a point :
                       point = (ivar-1)*number_of_values+value,
 where ivar is the position of the variable in L. So in the list LPoint the ith element takes the value of its symmetric
point. All points must be in the list, even the constant point.

          ex: horizontal symmetry (variable 1 permutes with 4, 2 with 3).
          sym(point,[16,17,18,19,20,11,12,13,14,15,6,7,8,9,10,1,2,3,4,5]).

Note: the values are between 0 and the maximum of all domains.

sym(varval,LVar,LVal):

In the case of just a permutation in variables or/and values it's not necessary to specifiy all points. So LVar and
LVal contain the list of (resp) variables and values permutations.

          ex: horizontal symmetry:
          sym(varval,[4,3,2,1],[0,1,2,3,4]).


reduced forms sym(point_red,LPointRed), sym(varval_red, LVarRed, LValRed):

It's possible to specify only the permuted points. The lists LPointRed, LVarRed and LValRed contain cycles of
permuted points, variables or values.

          ex: horizontal symmetry:
          sym(point_red,[[16,1],[17,2],[18,3],[19,4],[20,5],[11,6],[12,7],[13,8],[14,9],[15,10]]).
          sym(varval_red,[[1,4],[2,3]],[]).

For the cycles, list [a1,...,an] means "a1 becomes a2 becomes ... an becomes a1".

local symmetries sym(var_local,LVar,LocalVal), sym(val_local,LVal,LocalVar):

Local symmetries allows to specify a variable (resp. value) symmetry just for some values (resp. variables),
LocalVal (resp. LocalVar) contains only concerned values (resp. variables).

          ex: horizontal symmetry:
          sym(var_local,[4,3,2,1],[1,2,3,4]).  (here is a special case where all values except 0 are considered)
          vertical symmetry (line 1 permute with 4 and 2 with 3):
          sym(val_local,[0,4,3,2,1],[1,2,3,4}). (here is a special case where all variables are considered)

group of symmetries group(Sym):

group indicates that program must build all symmetries from generators contained in Sym with any representation
described above.

          ex: group of horizontal and vertical symmetries (must generates the 180° rotation)
          group([ sym(varval,[4,3,2,1],[0,1,2,3,4]), sym(varval,[1,2,3,4],[0,4,3,2,1]) ]).

The symmetrie wich corresponds to 180° rotation, like the two generators, are stored in the data structure of the program
and add to the other symmetries already specified. But the user have no access (for the moment) to the generated predicates.

3-Options:

The options of labeling are :

variable_method(V):

standard : leftmost variable is selected (default mode).
max : from the greatest variable to the smallest.
middle: from the middle variableto the bounds.
bounds: from the bounds variableto the middle.

value_method(V):

min : from the smallest value to the greatest (default mode).
max : from the greatest valueto the smallest.
middle: from the middle valueto the bounds.
bounds: from the bounds valueto the middle.
random: enumerates the values randomly, each value is only tried once.