chapter 9 – tree decomposition methods- part ii

Anagh Lal Tuesday, April 08, 2003 1

Chapter 9 – Tree Decomposition Methods- Part II

Anagh LalCSCE 990-06 Advanced Constraint Processing


Outline

• Unifying Tree-decomposition schemes– What is a tree-decomposition?

• Processing a tree-decomposition, Cluster-Tree Elimination (CTE)

• Join tree clustering as tree-decomposition• Adaptive-consistency as tree-

decomposition.


Unifying Tree-Decomposition Schemes

• We saw how JTC compiled a general an arbitrary constraint network into an acyclic one.

• We also saw an algorithm for solving acyclic networks.

• The unifying approach is presented as an algorithm combining the compilation phase and the solution phase of the compiled representation.


Tree decomposition

• Definition: R = (X, D, C) be a CSP problem. A tree decomposition for R is a triple <T,x,> , where T = (V, E) is a tree, x and are labelling functions which associate each vertex v from V with two sets x(v) X and (v) C that satisfy the following conditions:– Each constraint from C is part of some set (v) – Each variable in X, the set {v V | the variable is a part

of x(v)} induces a connected subtree of T (connectedness property)

Let’s see an example…


More definitions

• Tree-width: maximum cardinality from the set of x(v)

• Hyper-width: maximum cardinality from the set of (v)

• Separator: sep(u, v) = x(u) x(v)


Tree-decomposition and hypertree embedding

• Tree-decomposition defines a hypertree embedding of a hypergraph

• Smallest tree-width and hyper-width among all such embeddings are called the tree-width and the hyper-width of the constraint hypergraph, respectively.


Decomposable subproblem

• A subproblem of a constraint network is decomposable relative to the whole network if you can obtain solutions of the subproblem without referring to the remaining network

• A subproblem over a subset of Y variables is decomposable relative to the whole network, if its set of solutions is identical to the projection of the network’s solution on Y


Cluster-Tree Elimination (CTE)

• A tree decomposition facilitates solving many reasoning tasks including constraint satisfaction, optimization, and probabilistic reasoning tasks.

• Algorithm Cluster Tree Elimination (CTE) is used for processing a tree decomposition.

• The algorithm computes a decomposable subproblem for each node in the tree.


CTE-Algorithm

• Input: A tree decomposition <T,x,> for a problem R = <X, D, C>.

• Output: An augmented tree whose nodes are clusters containing the original constraints as well as messages received from neighbours. A decomposable problem for each node v.


Algorithm- Steps

for every edge (u,v) in the tree T, do– Compute message m(u,v) ( from u to v),

cluster(u) = (u) {m(i,u) | (i,u) T, iv}After node u has received messages from all adjacent vertices,

except maybe from v Compute and send to v:m(u,v) = sep(u,v)( cluster(u) Ri)

end forReturn: A tree-decomposition augmented with constraint messages. For

every node u T, return the decomposition subproblem cluster(u) = (u) {m(i,u) | (i,u) T, iv}


Complexity.

• N – number of nodes in the tree-decomposition.• w* be the tree-width• sep be its maximum seperator size• r- # constraints• deg – maximum degree in T• Space complexity: O(N.exp(sep))• Time complexity: O((r+N).deg.exp(w*))


Time complexity

• For a node u in the tree-decomposition T– # constraints processed = size of cluster

= |(u)| + deg – 1 – Time complexity of processing node u

(|(u)| + deg -1)exp(|x(u)|) = (|(u)| + deg -1)exp(|w*|) by definition of w*.Summing over all nodes | (u)| = rSo we have time complexity as (r.exp(w*) + N.deg.exp(w*) –

N.exp(w*) )This can be bounded by O(deg.(r+N).exp(w*))


Space complexity

The computation of message is done as follows:m(u,v) = sep(u,v)(JoinRi cluster(u) Ri)

Computing joins, storing them and then projecting will lead to a space complexity exponential in |x(u)| or |w*|. But projecting after every join step will lead to a space complexity exponential in the separator size (sep).

Thus for all nodes N, the space complexity is O(N.exp(sep))


JTC as tree-decomposition

• Example on board.• Space complexity

– JTC exponential in w*– CTE exponential in separator size, sep

• Time Complexity– JTC O(r.exp(w*)), If N < r– CTE O( r.deg.exp(w*))

• There are tree-decompositions that will not be created by JTC. Consider the example 9.2.13 …


Adaptive-consistency (AC) as tree-decomposition

• AC can be viewed as a message passing algorithm along a “bucket-tree”, which is a special case of tree-decomposition.

• Bucket-tree structure, first approach to description:– Consider a problem R = (X,D,C) and ordering d– Each bucket Bxi contains those constraints in C whose latest

variable in d is xi

– A bucket-tree of R and an ordering d, has buckets as its nodes, and bucket Bx is connected to bucket By if the constraint generated by adaptive-consistency in bucket Bx is placed in By

– In a bucket-tree every node Bx has one parent node By


Bucket-tree structure

• Bucket-tree structure, graph based description:– Let Gd be the induced graph along ordering d of

problem R having primal graph G.– Each variable x, and all of its earlier neighbours

in the induced-graph reside in bucket Bx

– Each node Bx points to By (By is the parent of Bx) if y is the latest earlier neighbour of x in Gd


Bucket-tree is a tree-decomposition

• Proof: Given problem R, its bucket-tree and two mappings:– x(Bx) contains x and its earlier neighbours in the

induced graph along ordering d. (Bx) contains all constraints whose highest-ordered

argument is x– To prove

1. Each constraint from C is part of some set (v) and2. Each variable in X, the set {v V | the variable is a part of

x(v)} induces a connected subtree of T (connectedness property)


Proof

• By construction of the bucket-tree, the first requirement (for the labelling x) holds

• Proof of connectedness:Proof by contradiction.


Adaptive Tree Consistency

• Since the bucket-tree is a tree-decomposition, it can be processed by CTE.

• CTE adds a bottom-up message passing to adaptive consistency yielding Adaptive Tree Consistency (ATC).

• Top-down phase: Each bucket receives messages from its children and sends to its parent AC.

• Bottom-up phase: Each bucket receives a constraint from its parent and sends constraints to its children.


Algorithm

• Input: Problem R =(X,D,C), ordering d• Output: Augmented buckets containing

and all the constraints received from neighbours in the bucket tree.

• Steps:– Step 0: Pre-processing– Step 1: Top-down phase– Step 2: Bottom-up phase


Steps-0,1

• Pre-processing:– Generate a bucket-tree using induced graph Gd

• Top-down phase (AC):– For i= n to , process bucket Bxi:

• Let 1,…, j be all the constraints in Bxi , including the original constraints of R.

• The constraint yxi sent from xi to its parent yyxi (sep (xi,y)) = sep(xi,y) ( Join)j

i=1 i


Step-2

• Bottom-up phase:– For i= n to , process bucket Bxi:

• Let 1,…, j be all the constraints in Bxi , including the original constraints of R

• The constraint zjxi sent from each child zj

zjxi (sep (xi, zj)) = sep(xi,zj)

( Join)ji=1 i


Interesting note

• Since a bucket-tree is a tree decomposition, and since it can be shown theat CTE applied to a bucket-tree is equivalent to ATC, then ATC :– Generates back-track free representation along

certain orderings (width = 1) and,– Augments this representation with the

generation of minimal subproblems.


Complexity of ATC

• Notation:– w* - induced width along ordering d– deg – maximum degree in the bucket-tree– r- # constraints

• Time complexity – O(r.deg.exp(w*))

• Space complexity– O(n.exp(w*))


Discussion

• Questions• Comments

chapter 9 – tree decomposition methods- part ii

Documents