Sequences Constraints For Physical Mapping Problem

Sequences Constraints for Physical
Mapping Problem
Hamza Zidoum
Abstract The physical mapping is a crucial tool in the analysis of the genomic sequences. Algorithms for the mapping
process are based on NP-complete combinatorial optimizations. PQ-trees have been extensively used to manipulate the
hybridization matrix. This paper presents an extension of PQ-trees. A PQR-tree1 is a suitable data structure for testing the
Consecutive Ones Property (COP), besides it can handle partial orders information on probes. Moreover, we embed PQR-trees
in the more general framework of Constraint Programming (CP). We introduce Sequences and present the filtering algorithms
for checking sequence constraints consistency. A PQR-tree is a canonical form that characterizes a family of sequential
arrangements of a given set. The relations we are dealing with are classical sets relations e, c, =, = besides sequencing
relations such as group, potential, metric and range constraints. The filtering algorithm is based on incremental consistency
techniques used to reduce PQR-trees, hence pruning the inconsistencies before the labeling phase. We claim that the
sequence structure introduces a flexibility criterion on CP which renders it a suitable tool for solving NP-complete combinatorial
problems related to sequencing as in physical mapping problems.
Index TermsConstraint Programming, Filtering algorithms, Physical Mapping, Consecutive One Property.

1 INTRODUCTION

he physical mapping is a crucial tool in the analysis
of the genomic sequences. Sequencing involves divid-
ing a large segment of DNA into overlapping pieces
then combining information about the pieces into infor-
mation about the hole which involves reordering frag-
ments [7]. Algorithms for the mapping process are based
on NP-complete combinatorial optimizations. PQ-trees
are extensively used to represent the information in the
hybridization matrix in a compact way [5], [6], [9], and
[10]. Besides, PQ-trees were used to represent a set of
conserved intervals used for reconstructing ancestral gene
orders [1], and to elaborate a computational model for the
haplotyping problem [4].
We propose first, to extend PQ-trees to encompass
properties besides the consecutive ones, such as prece-
dence and diameter relations and second, embed PQR-
trees in Constraint based Programming framework.
Constraint programming is an emergent software tech-
nology for declarative description and effective solving of
large, particularly combinatorial, problems. Constraint
programming CP, has been successfully applied in nu-
merous domains especially in areas of planning and
scheduling. A great part of the success of constraint pro-
gramming techniques in solving combinatorial problems
is due to the capabilities of filtering algorithms to prune
the search space. Moreover, CP technology is mature for
the elegant modeling and efficient solving of NP-
complete combinatorial optimizations problems.
We propose new techniques for solving constraints on
a collection of ordered objects named Sequence. We expli-
citly introduce new relations such as group, preceding,
and diameter to be able to reason efficiently on three
types of constraints set, potential and metric constraints.
2 PHYSICAL MAPPING
We consider a collection of known substrings of the
DNA also known as probes denoted by Pi and a set of
fragments of the DNA called Clones denoted by Cj. The
physical mapping problem consists of finding the order-
ing of the probes and clones in the DNA. Hybridization
experiments determine whether a clone Cj contains the
substring denoted by Pi. The experiments record the hy-
bridizations of some probes with some clones and the
result is the hybridization matrix. The hybridization ma-
trix A is defined by A[Cj, Pi] =1 if the interval of Cj is de-
termined to hybridize with the probe Pi and 0 otherwise.
The hybridization matrix A record only the relative po-
sition of clones and probes, the exact position being irre-
trievable. If we determine the relative order of the probes
then we can retrieve the relative order of the clones. Let
Pn be the set of permutations of the set {1,,n}. A permu-
tation t e Pn is a probe order.
t
A
is the matrix resulting
from permuting the n columns of A according to the
permutation t. The matrix A has the consecutive ones
property if there exists a permutation t e Pn such that the

- Hamza Zidoum is with the Departmnt of Computer Science, Sultan Qa-
boos University, PO. Box 36, Al Kho123, Oman.

T
JOURNAL OF COMPUTING, VOLUME 4, ISSUE 3, MARCH 2012, ISSN 2151-9617
https://sites.google.com/site/journalofcomputing
WWW.JOURNALOFCOMPUTING.ORG 20

column-ordered matrix
t
A
, where t is a consistent
probe order. The true map of the genomic placement is
0
t
A
where t0 is the true probe order.
3 DATA STRUCTURE
3.1 PQ--Trees
PQ-trees were introduced by Booth and Lueker [2] to
construct the set of all permutations of a set E that are
consistent with constraints of consecutiveness given by a
collection C of subsets of E with the convention that the
elements of each subset C in E must occur consecutively
in the permutation.
The literature on problems related to PQ-trees is quite
extensive. PQ-trees can be applied to test the consecutive
ones property of (0,1)-matrices [2], to recognize interval
graphs [11] and to recognize planar graphs [12]. Korte
and Mhring [14] considered a modified PQ-trees and a
simpler incremental update of the tree for the purpose of
recognizing interval graphs. Klein and Reif [15] con-
structed efficient parallel algorithms for manipulating
PQ-trees. Shih and Hsu [13] introduced a generalization
of PQ-trees for planarity test.
A PQ-tree is a rooted tree T with two types of internal
nodes: P and Q, which will be represented by circles and
rectangles, respectively. The leaves of T correspond 1-1
with the columns of M. Figure 1 gives an example of a
matrix satisfying the Consecutive Ones Property COP
and its corresponding PQ-tree.

The frontier of a PQ-tree T, denoted by FRONTIER (T),
is the permutation of the columns obtained by ordering
the leaves of T from left to right. Such a permutation is
called a consistent permutation. Booth and Lueker algo-
rithm considers each row as a constraint and adds them
one at a time. Each time a new row is added (a new itera-
tion starts), the algorithm tries to modify the current PQ-
tree to satisfy the consecutiveness constraint of columns
of the newly added row. To guarantee unique PQ-tree
representations we need to restrict ourselves to proper
PQ-trees: every P-node has at least two children; every Q-
node has at least three children. Two PQ-trees are equiva-
lent iff one can be transformed
to the other by applying zero or more equivalent trans-
formations. The equivalence of two trees is written T~T.
There are two types of equivalent transformations:
1. Arbitrarily permute the children of a P-node,
2. Reverse the order of the children of a Q-node.
Denote the set of all consistent permutations (or fron-
tiers) of a PQ-tree T by
CONSISTENT (T) = {FRONTIER (T) | T~ T}.
Given a PQ -tree T and a row u of M, define a new tree
called the u-reduction of T to be one whose consistent
permutations are exactly the original permutations in
which the leaves in u occur consecutively. This new tree
is denoted by REDUCE(T,u). Booth and Lueker gave a
procedure REDUCE to obtain the u-reduction. The pro-
cedure applies a sequence of templates to the nodes of T.
Each template has a pattern and a replacement. If a node
matches the templates pattern, the pattern is replaced
within the tree by the templates replacement. This is a
bottom-up strategy that examines the tree node-by-node
obeying the child-before-parent discipline.
A node is said to be full if all of its descendant leaves
are in u; It is empty if none of its descendant leave s are in
u; If some but not all of the descendant leave s are in u, it
is said to be partial. Nodes are said to be pertinent if they
are either full or partial. The pertinent subtree of T with
respect to u, denoted by PERTINENT(T, u), is the subtree
of minimum height whose frontier contains all columns
in u. The root of the pertinent subtree is denoted by
ROOT(T, u), which is usually not the root of the entire
tree. A small set of templates are used as shown in Figure
9. Trivial cases have been skipped on purpose. Two
passes are used in the actual implementation. The first
identifies the nodes to be processed and the second ap-
plies the templates. The algorithm classifies each node as
empty, full, or partial and then perform a pattern re-
placement.
1 2 3 4 5 6
1 1 0 0 0 0
0 1 1 0 0 0
1 1 1 1 0 0
0 0 0 1 1 1
0 0 0 0 1 1
1 2 3
4
5 6
Figure1. PQ-Tree or a matrix satisfying the Consecutive Ones
Property

Figure 2. PQ-Tree Transformations
3.2 PQR TREES
PQR-trees are an extension to PQ-trees and represent
the set of sequences coherent with an ordered hypergraph
of intervals. An ordered interval hypergraph is a hyper-
graph with partial order over the leave such that there is
at least one permutation of the leave that transforms the
edges into closed intervals. PQR tree were used schedul-
ing to solve flowshop and jobshop problems [8].
A PQR-tree is a tree that represents for a given set E, all
the permutation for which some parts of E remain closed
intervals. We could say that a PQR tree represents an
oriented interval hypergraph (H(E,F),R) if we consider
the latest as a set of acceptable sequences i.e.; where F are
segments coherent with order relation R.
R-nodes represent oriented sub-sequences (total order)
and are represented by a rectangle with an arrow that
indicates the node orientation.

Example:
Let S be the sequence defined over a set
E = {a, b, c, d, e, f, g}
along with the following constraints:
cons({d, e} , S), cons({a, b, c} , S), cons({e, f} , S), prec({a}, {c} ,
S), cons({f, g} , S), prec({e}, {b} , S).
The PQR frontiers are:
CONSISTENT (T) = {{d, e, f, g, a, c, b}, {d, e, f, g, a, b,
c}, {d, e, f, g, b, a, c}, {g, f, d, c, b}, {g, f, e, d, a, b, c}, {g,
f, e, d, b, a, c}}.

Initial PQR tree cons({d, e} , S,

cons({e, f} , S) cons({f, g})

cons({a, b, c} , S) prec({a}, {c} , S),

prec({e}, {b} , S and Final PQR Tree

Figure 3. PQ-Tree Reduction
4 SEQUENCE CONSTRAINTS
Constraint programming CP is an emergent software
technology for declarative description and effective solv-
ing of large, particularly combinatorial, problems. The
tool developers have integrated various sophisticated
operations research (OR) algorithms which allow their
constraint solvers to make more powerful inferences, and
thus find solutions more efficiently. Constraint program-
ming is a rapidly maturing technology, and several com-
mercial tools are available such as OPL, and Comet. OPL
a b c d e f g a b c
d e
f g
a b c
d e f
g
a b c
d e f g
a b c
d e f g
a b c
d e f g
a b c
d e f g

is a modeling language for mathematical programming
and combinatorial optimization problems [16]. It com-
bines high-level algebraic and set notations from model-
ing languages with a rich constraint language and the
ability to specify search procedures and strategies that is
the essence of constraint programming. Comet is a tool
for solving complex combinatorial optimization problems
underlying Constraint-based Local Search [22].
Several models such as graphs, POSET, Integer pro-
gramming, Petri nets were exploited in Operational Re-
search OR, in solving NP-hard combinatorial optimiza-
tion problem related to sequencing. Nevertheless some
important constraints are traditionally bypassed for they
cannot be directly integrated in those models. The group
constraint for instance, where a sub-set of objects has to
be consecutive in any admissible sequential arrangements
could be represented in integer programming IP thanks
to range equations

x, y |(x, S) - (y, S)| < card (S)

It is possible to take sequencing constraints into ac-
count but only with considerable computational efforts
(due to the disjunction), resorting to a complex model
that involves including non-intuitive.
We introduce consistency techniques over sequences
constraints embedded in Constraint Programming. Se-
quences constraints characterize a family of admissible
sequences/permutations. We consider classical sets rela-
tions (e, c, =, =) and sequencing relations as potential,
metric and range constraints. We define the semantics of
these relations with a characteristic range function. The
consistency techniques used are incremental reduction of
the normal form based on a tree like representation called
PQR-trees. This allows us to reduce the set of admissible
sequences before generating solutions.
Constraint satisfaction on Sequences is achieved in four
different ways: (1) information on rank relationships lead
to reduction of the PQR tree. (2) Group and precedence
constraints are reduced in a linear time. (3) rank con-
straints consistency checking is performed via a finite
domain solver, and finally (4) the labeling procedure con-
sists of enumerating all valid instances
The actual constraint system is defined by the pair (O,
I) where O represents the solved form and O represents
the non-solved form.
Let O be the solved form, sequence constraints have the
form of the triplet (S, E, T): S a variable of type sequence:
a sequence is denoted by sq{ai, ai+1,, an}, n > 0, and
represents the collection of objects according to a given
order defined in predicate form. Empty sequence is de-
noted sq{}. For instance, the following constraints S<- seq
{a, b, c, d}, cons({b,d}, S}, prec({a}, {c, d}, rank(c, S, r), r > 3)
corresponds to the following sequences {sq{a, b, c, d},
sq{a, d, b,c}} E is a homogeneous set, and T, a PQR tree
defined over the set E

4.1 FILTERING ALGORITHMS FOR ORDERING
CONSTRAINT

The procedure filter_seq_ordering(O, I, S, T, A, B) con-
sists of reducing the solved form O i.e.; the PQR-tree such
that the domain of the sequence S contains only sequen-
tial arrangements that satisfy the precedence relationship
between elements of sets A and B, namely every element
of the set A precedes any of the elements of set B.
Starting from leaves labeled A, and B we go upward
until we reach the root r of the sub-tree that contains all
leaves labeled A and B. Depending on the type of r, we
apply one of the following procedures:
t( n) = Q, replace node n with a node of type r such
that the relationship A< B is satisfied.
t( n) = R, perform a simple check, namely if the orienta-
tion of the node R is coherent with the precedence rela-
tionship A< B
t( n) = P
if adding the constraint A< B induces a complete order
over the children of the node n, replace node change the
type of the n to R, otherwise we check for inconsistencies
as for instance of the type B< A that reduces the reduced
form to the nil PQR-tree. The nil tree is a PQR-tree with-
out any node or leave, so that it the nil tree has no frontier
and the set of consistant permutation is empty. In conse-
quence the nil-tree cannot be reduced.
Constraints are explicitly expressed with the following
relationships:
set relationships: =, =, e, e, # (cardinality)
precedence: prec/3
group/subsequence: cons/2
rank relationship: rank/3
metric relationship: diam/3

The non-solved form denoted I encapsulates those
constraints that could not be taken into account via the
PQR-Tree. Mainly, these constraints have the following
form:
rank(x
i
, S) o N
where o e{=, =, <, >, s , > }
The domain of these variables is partially solved by the
PQR-tree reduction as shown in figure 4. To each node n
of the PQR-tree we can associate a domain Dom(n)=[r
min
,
r
max
] that represents the set of integer values for the rank
that can be taken by the leaves given by the function

FRONTIER (T'(n)) where FRONTIER (T'(n)) is the set of
leaves belonging to the sub-tree T' whose root is the node
N:
xe FRONTIER (T'(n)), r
min
s(x, S)s r
min

For the root of the PQR-tree the domain is trivially:
Dom(ROOT)=[1,Card(S)]

filter_seq_ordering(O, I, S, T, A, B)
PRECEDE, ORDER, POSSIBLE: boolean
Begin
root(T, A, B, N)
case N of
node Q: replace N with a node of type R such that
PRECEDENCE(A, B, PRECEDE) and PRE-
CEDE
node R:
Begin
CHILDREN(T, N, F)
// Let f be the ancestor of A | f e F
// Let g be the ancestor of B | g e F
PRECEDENCE(f, g, PRECEDE)
If !PRECEDE then
Begin
T nil_tree
Exit
End
End
node P
Begin
DETECT_TOTAL_ORDER(T, N, ORDER)
If ORDER then REPLACE(N, R, O )
Else
Begin
PRECEDENCE(N, T, POSSIBLE)
If !POSSIBLE then
Begin
T nil_tree
Exit
End
End
End
End

Filtering algorithm for the Order constraint

Definitions:

PARENT(n) represents the parent for the node n
S(n) represents the set of siblings of a node n
S(n)={x| PARENT (x)= PARENT (n)}
S
p
(n) represents the set of predecessor nodes of a node n
S
p
(n)={x|xeS(n), x< n}
where the symbol< denotes the precedence relation-
ship between nodes x and n: x precedes n. Ss(n)
represents the set of successors nodes of a node n
Ss(n)={x|xeS(n), n < x }. For the rest of the nodes, we
distinguish three cases: (1) Case where the parent of the
node n is of type P: t( PARENT (n) )=P
Dom(n)=[r
min
(PARENT (n))+

e ) (n S i
i
p
w , r
max
(PARENT (n))-
e ) (n S i
i
s
w ]
(2) Case where the parent of the node n is of type Q: t(
PARENT (n) )=Q
Dom(n)=[r
min
(PARENT (n))+K, r
max
(PARENT (n))-K]
where ) , min(
) ( ) (

e e
=
n S i
i
n S i
i
s p
w w K
(3) Case where the parent of the node n is of type R: t(
PARENT (n) )=R
Dom(n)=[r
min
(PARENT (n))+
e ) (n S i
i
p
w , r
max
(PARENT (n))-
e ) (n S i
i
s
w ]
Example: Given the following PQR-tree

Dom(A)= Dom(B)= [1, 11]
Dom(C)= Dom(D)= Dom(E)= Dom(F)=[4, 11]
Dom(k)=[1, 11]
Dom(b)=[2, 3]
Dom(c)=[3, 4]
Dom(d)=[4, 11]
Dom(e)=[5, 10]
Dom(f)=[4, 9]
Dom(g)=[6, 11]
Dom(h)=[6, 11]
Dom(i)=[4, 11]
Dom(j)=[4, 11]

A
B
C
D
F E
i
j
h
a b c
d e
f g
k

Figure 4. Constraint Resolution

4.2 Labeling Ground instances
The constraints solved by the solved form are (1) group
constraints cons(G, S) which holds if in all permissible
permutations S of a given set E, the elements of a subset G
of E are consecutive, and (2) order constraints which spe-
cify partial orders on a family of arrangements S of set E.
In the same time, we check the satisfiability of metric
constraints over sequences. In fact the introduction of
range intervals in the PQR-tree representation of the se-
quences facilitates (1) the early detection of domain in-
consistencies over metric constraints, and (2) the propaga-
tion of domains consistency through the PQR-tree nodes
whenever it is possible. When Group and Order con-
straints are satisfied, the PQR-tree representation pro-
vides for each node or leaf a range interval. Consequent-
ly, the satisfiability of metric constraints which are rewrit-
ten into an equivalent system of rank constraints (using
the function ) can be tested. The filtering algorithm can
effectively detect range inconsistencies and reduce the
domain of consistent range values. Only when nothing
else can be done, then a finite domain solver is used. Ge-
nerating the PQR-tree frontiers which satisfy the finite
domain solutions as well is the last step in forming the
desired sequences.

5 SYSTEM TESTING & PERFORMANCE

COP(S)
S :: {1,2,3,4,5},
G = {{1 1 0 1 1},
{0 0 0 1 0},
{1 1 1 1 0},
{0 1 0 1 1},
{1 0 1 1 0}},
forall x in G do cons(x, S),
enum(S).

The CP program above calculates the set of permuta-
tions of the lines of the matrix in upper left corner, such
that the ONES are consecutive

Figure 5. Time for CP(Sequence)

time [sec]
-2

+
140
120
100
15 25 30 35 20
60
80
+
+ +
+
card(S)
1 1 0 1 1
0 0 0 1 0
1 1 1 1 0
0 1 0 1 1
1 0 1 1 0
1 1 0 0 0
1 0 0 0 1
0 1 1 0 0
0 0 0 1 1
0 0 1 1 0
1 0 0 0 0
1 1 0 1 1
0 1 1 1 1
0 0 1 0 1
0 0 0 1 0
0 1 0 1 1
1 1 0 1 1
1 1 1 1 0
1 0 1 1 0
0 0 0 1 0
1 0 0 0 1
1 1 0 0 0
0 1 1 0 0
0 0 1 1 0
0 0 0 1 1

Finite Domain
Solver
Constraint C
k

Group/Subsequence
&
Precedence constraints
Resolution
Partial Consistency Test
for rank constraints
PQR Tree
Finite Domain
Solver
Sequence
Labeling
PQR-Tree
reduction

Figure 6. Time for Finite Domain Solver CHIP

The filtering algorithm using the solved and compact
form of the PQR-trees is performed in a linear time [20].
However the use of the finite domain solver slow down
the computation performances as the solver uses arc con-
sistency algorithms of the type of AC-3 [19], and a labe-
ling algorithm based on "forward checking" procedure
[21].

6 DISCUSSION

The main contribution of sequence data structure is the
formal computation over a family of sequences. The filter-
ing mechanism over sequences constraints is based on the
elimination of all the inconsistent arrangements of the
original set by an incremental reduction of the internal
tree like representation based on the structure of PQR-
trees. PQR-tree is a super set of partial orders where the
frontier represents a consistent sequential arrangement of
the original set. Each transformation of a PQR tree pro-
vides an equivalent PQR-tree. The set makes up by the
tree frontiers of the equivalence class represents the valid
arrangements of the original set. We can hence express set
constraints in a simple and elegant manner. In particular,
it permits a canonical representation of all the arrange-
ments sequences on an arbitrary set taking into account
the constraints of heterogeneous types: potential con-
straints and set constraints. The approach adopted to
solve metric constraints is a bit more complex. The main
idea is to further exploit the tree like representation to
compute, for each element x of the original set, a range
interval which bounds the consistent range values of x.
Labeling is the transformation of the PQR-tree into its
equivalent trees and permits to keep only consistent fron-
tiers. We think that the sequence structure introduces a
suitable flexibility criterion on CP which renders it a suit-
able tool for solving physical mapping related problems.
The next step is to tackle the harder probe-clone hybridi-
zation data in the presence of false positives and nega-
tives.
ACKNOWLEDGMENT

This work was supported by SQU internal research grant
IG/SCI/COMP/08/03.
REFERENCE

[1] A. Bergeron, M. Blanchette, A. Chateau and C. Chauve, "Reconstructing
Ancestral Gene Orders Using Conserved Intervals" Lecture Notes in Comput-
er Science, Pages 14-25, Vol. 3240/2004.
[2] K.S. Booth and G.S. Lueker. "Testing for the consecutive ones property,
interval graphs, and graph planarity using PQ-tree algorithms.", J. Comput.
System Sci., 13(3):335379, 1976.
[3] E. Tsang. "Foundations of Constraint Satisfaction" Academic Press, 1993.
[4] P. Bonizzoni, G. Della, V. Riccardo, D. Jing Li. "The haplotyping problem:
an overview of computational models and solutions", Jour. of Computer Science
and Technology, 2003.
[5] David S. Greenberg, Sorin Istrail. "Physical mapping by STS hybridization:
Algorithmic strategies and the challenge of software evaluation", Journal of
Computational Biology (1995).
[6] T. Christof, M. Junger, J. Kececioglu, P. Mutzel, G. Reinelt. "A branch-
and-cut approach to physical mapping of chromosomes by unique end-probes".
Proc. of the 1st annual int. conf. on Computational molecular biology Santa Fe,
New Mexico, U.S.A, Pages: 84 92, 1997.
[7] R. Backofen, D. Gilbert, "Bioinformatics and Constraints", Constraints, Vol.
6 , Issue 2-3 (June 2001), Pp 141 156.
[8] P. Paptiste, C.H.P. Cho, J. Favrel, "A new concept for scheduling system: the
PQR tree application to flowshop and jobshop scheduling, Advances in Produc-
tion Management Systems, Elsevier Science Publishers, pp 551-558 IFIP 1991.
[9] S. Batzoglou, and S. Istrail, Physical Mapping with Repeated Probes: The
Hypergraph Superstring Problem, Lecture Notes in Computer Science, Vo-
lume 1645/1999, Pages 66-77
[10] S. Heber, J. Stoye, M. Frohme, J. Hoheisel, M. Vingron. "Contig Selection
in Physical Mapping", Journal of Computational Biology. Aug 1, 2000, 7(3-4):
395-408.
[11] D. Fulkeson, O. Gross, "Incidence matrices and interval graphs". Pacific J.
Math. Volume 15, Number 3 (1965), 835-855.
[12] A. Lempel, S. Even, and I. Cederbaum, An algorithm for planarity testing
graphs, in Theory of Graphs, P. Rosentiehl, ed., Gordon and Breach, NewY ork,
1966, pp. 215232.
[13] HSU Wen-Lian, "PC-trees vs. PQ-trees", 7th Annual International Confe-
rence, COCOON 2001, Guilin, China, August 20-23, 2001.
[14] N. Korte and R. H. Mhring, "An Incremental Linear-Time Algorithm for
Recognizing Interval Graphs, SIAM J. Comput. 18, 1989, 68-81.
[15] P.N. Klein and J.H. Reif, An efficient parallel algorithm for planarity, J. of
Computer and System Science 37, (1988), 190-246.
[16] P. VAN HENTENRYCK ; L. MICHEL , L. PERRON, J.-C REGIN,
"Constraint Programming in OPL". In International Conference on Principles
and Practice of Declarative Programming (PPDP'99), Paris, France, Septem-
ber 1999
[17] A. K. Mackworth. "Constraint satisfaction". In S. C. Shapiro, editor, Encyc-
lopedia of Artificial Intelligence. JohnWiley and Sons, New York, 1987.
[18] Bernard A. Nadel. "Constraint satisfaction algorithms". Computational
Intelligence, 5:188224, 1989

+
time [sec]
3

+
8
6
4
15 19 21 35 17
0
2
+
+
+
card(S)
10

[19] A. K. Mackworth 1977. Consistency in Networks of Relations,, Art. Int.8(1)
(1977) 118126.
[20] H. Zidoum, "Rsolution de Contraintes sur les Squence" Thse de l'Univer-
sit de Franche-Comt, 144 pp, 1996
[21] R. M. Haralick and G. L. Elliott. Increasing tree search efficiency for con-
straint satisfaction problems. Artificial Intelligence, 14:263313, 1980.
[22] P. Van Hentenryck and L.Michel, Constraint-Based Local Search. The MIT
Press, 2005.

Hamza Zidoum graduated from University of Ferhat Abbas, Stif,
Algeria. He received both his Diplme dEtudes Approfondies (DEA)
in 1991, and Ph.D. in Computer Science in 1996 from the University
of Franche-Comt, Besanon. In 2002 he joined the Department of
Computer Science at Sultan Qaboos University. He is member of
Association of Logic Programming ALP, and Association for Compu-
ting Machinery, ACM.


Sequences Constraints For Physical Mapping Problem

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Sequences Constraints For Physical Mapping Problem

Uploaded by

Copyright:

Available Formats

Sequences Constraints for Physical

You might also like