ConstraintSolver 0.1

data/lib/ConstraintList.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/ruby
+
+module ConstraintSolver
+    # This class represents a list of constraints.
+    class ConstraintList < Array
+	# Returns the ConstraintList that contains all constraints that involve
+	# variable and have values assigned to not all variables involved.
+	def notAllAssignedWithVariable(variable)
+	    ConstraintList.new(self.select { |constraint|
+		constraint.include?(variable) and not constraint.allAssigned?
+	    })
+	end
+	#
+	# Returns the ConstraintList that contains all constraints that involve
+	# variable.
+	def allWithVariable(variable)
+	    ConstraintList.new(self.select { |constraint|
+		constraint.include?(variable)
+	    })
+	end
+
+	def sort(&block)
+	    ConstraintList.new(self.sort!(&block))
+	end
+
+	def -(element)
+	    new = self.to_a - (element.kind_of?(Array) ? element : [ element ])
+	    return ConstraintList.new(new)
+	end
+    end
+end

data/lib/ConstraintSolver.rb

@@ -0,0 +1,213 @@
+#!/usr/bin/ruby
+
+require 'log4r'
+include Log4r
+
+%w(AbstractConstraint AllDifferentConstraint BinaryConstraint
+    TupleConstraint OneOfEqualsConstraint ConstraintList ConstraintSolver Domain
+    extensions Problem Solution Variable).each { |file| require file }
+
+module ConstraintSolver
+    class ConstraintSolver
+	attr_reader :log
+	# Initialises a new solver.
+	def initialize(log=nil)
+	    if log.nil?
+		@log = Logger.new(self.class.to_s)
+	    else
+		@log = log
+	    end
+	end
+
+	# Attempts to solve the constraint satisfaction problem passed as an
+	# argument and returns a list of all solutions. If there are no
+	# solutions, an empty list is returned. The second argument is the time
+	# limit to find a solution to the problem in seconds. This parameter is optional.
+	# A queue of constraint lists to consider is assembled at the beginning
+	# and only contains the initial list of constraints. While the problem
+	# is solved, additional constraint lists may be added to the queue. The
+	# new lists are relaxed versions of the problem with soft constraints
+	# removed. These are processed one at a time.
+	def solve(problem, limit=false)
+	    @limit = limit
+	    @problem = problem
+	    @constraintChecks = 0
+	    @nodeChecks = 0
+	    @solutions = []
+	    @time = Time.now
+	    sortedConstraints = @problem.constraints.sort { |a,b| a.violationCost <=> b.violationCost }
+	    if @limit
+		a = @limit * 100
+		@discardTimes = Hash.new
+		b = Math.log((a * sortedConstraints.last.violationCost / @limit) + 1) / @limit
+		sortedConstraints.each { |cons|
+		    time = Math.log((a * cons.violationCost / @limit) + 1) / b
+		    if not @discardTimes.has_key?(time)
+			@discardTimes[time] = []
+		    end
+		    @discardTimes[time] << cons
+		}
+	    end
+	    @constraintsQueue = [ [ sortedConstraints, 0 ] ]
+	    while not @constraintsQueue.empty?
+		@timeDroppedConstraints = []
+		constraints = @constraintsQueue.shift
+		retval = assignNextVariable(@problem.variables.sort { |a,b| b.merit <=> a.merit },
+				   constraints[0], constraints[1])
+		break if (retval == :solution and @problem.firstSolution) or (retval == :timeout)
+		@constraintsQueue.uniq!
+	    end
+	    return @solutions, @nodeChecks, @constraintChecks
+	end
+
+	private
+
+	# Attempts to assign a value that is consistent with all constraints to
+	# the next variable. Arguments are the list of variables left to
+	# process, the list of constraints to consider, and a measure for the
+	# current violation of constraints.
+	# Returns :solution iff a solution to the constraint satisfaction problem was
+	# found; i.e. before the call there was only one unassigned variable and
+	# a value that is consistent with all constraints was found in its
+	# domain or the sum of the cost of all violated constraints is less than
+	# the maximum cost for the problem. Else :noSolution if no solution was
+	# found or :timeout if the time limit for solving was exceeded is
+	# returned.
+	# If a constraint is violated, but the cost still below the maximum
+	# cost, a new list of constraints without the offending constraint is
+	# added to the queue of list of constraints to process. It is not
+	# processed immediately because first all the prunings have to be
+	# undone, so the exploration of the current search tree finishes and
+	# cleans up after itself.
+	# This method calls checkNode to test a particular assignment.
+	def assignNextVariable(variables, constraints, violation)
+	    if @limit
+		return :timeout unless (Time.now - @time) < @limit or @solutions.empty?
+		discard = @discardTimes.keys.partition { |t| t <= Time.now - @time }[0]
+		discardConstraints = discard.collect { |k| @discardTimes[k] }.flatten
+		discardConstraints &= constraints
+		unless discardConstraints.empty?
+		    @log.info("Running out of time, discarding constraints " + discardConstraints.join(", "))
+		    constraints -= discardConstraints
+		    @timeDroppedConstraints += discardConstraints
+		end
+	    end
+	    retval = :noSolution
+	    current = variables.first
+	    if current.assigned?
+		allHolds = true
+		constraints.allWithVariable(current).each { |constraint|
+		    @constraintChecks += 1
+		    holds = constraint.holds?
+		    if holds == false
+			if (violation + constraint.violationCost) <= @problem.maxViolation
+			    @log.debug("Discarding constraint " + constraint.to_s +
+				", cost " + constraint.violationCost.to_s)
+			    @constraintsQueue << [ constraints - constraint, violation + constraint.violationCost ]
+			end
+			allHolds = false
+		    end
+		    break unless allHolds
+		}
+		retval = checkNode(current, variables, constraints, violation) if allHolds
+	    else
+		values = current.domain.sort { |a,b|
+		    (@problem.meritMap.has_key?(b) ? @problem.meritMap[b] : 0) <=>
+		    (@problem.meritMap.has_key?(a) ? @problem.meritMap[a] : 0)
+		}
+		values.each { |value|
+		    current.value = value
+		    retval = checkNode(current, variables, constraints, violation)
+		    break if (retval == :solution and @problem.firstSolution) or (retval == :timeout)
+		}
+		current.reset
+	    end
+	    return retval
+	end
+
+	# Checks a particular node in the search tree. Arguments to the method
+	# are the current node denoted by an assigned variablem the list of
+	# variables to process, the list of constraints to consider, and the
+	# current measure of violation cost.
+	# The method revises the constraints that the current variable is
+	# involved in, terminates the search if a domain wipeout occured or
+	# records a solution if one is found. Violated constraints may be
+	# disregarded if the cost of their violation plus the current costs of
+	# constraint violations is less than the maximum violation allowed for
+	# the problem.
+	# If the assignment is consistent but there are still unprocessed
+	# variables, it recursively calls assignNextVariable. Returns :solution iff a
+	# solution was found, :noSolution if none was found and :timeout if the
+	# time limit for solving the problem was exceeded.
+	def checkNode(node, variables, constraints, violation)
+	    retval = :noSolution
+	    @nodeChecks += 1
+	    @log.debug("Checking node " + node.to_s)
+	    revisedDomains, wipeout, constraints, violation = reviseConstraints(node, constraints, violation)
+	    unless wipeout # if a domain was wiped out we can skip the rest of the subtree
+		if variables.size == 1
+		    @constraintChecks += @timeDroppedConstraints.size
+		    violation += @timeDroppedConstraints.inject(0) { |cost,cons|
+			cost + (cons.holds? ? 0 : cons.violationCost )
+		    }
+		    solution = Solution.new(@problem.variables, @problem.meritMap, violation)
+		    unless @solutions.include?(solution)
+			@log.info("Found solution " + solution.to_s)
+			@solutions << solution
+		    end
+		    retval = (@limit and (Time.now - @time) > @limit) ? :timeout : :solution
+		else
+		    retval = assignNextVariable(variables.rest, constraints, violation)
+		end
+	    end
+	    revisedDomains.each { |domain| domain.undoPruning }
+	    return retval
+	end
+
+	# Revises all constraints that involve <i>variable</i>. Additional
+	# arguments are the list of constraints to consider, and the current
+	# cost of constraint violations.
+	# If a domain is wiped out during pruning, a new list of constraints
+	# with the constraint that caused the wipeout removed is added to the
+	# queue of constraint lists to process, the offending constraint is
+	# removed from the list of constraints, the cost of violation updated,
+	# and the pruning of the domains undone.
+	# Returns the list of domains that have been revised, a boolean
+	# indicating whether a domain was wiped out during pruning, the list of
+	# constraints, and the current cost of violation.
+	def reviseConstraints(variable, constraints, violation)
+	    revisedDomains = []
+	    wipeout = false
+	    queue = constraints.notAllAssignedWithVariable(variable)
+	    while not queue.empty?
+		revisedConstraint = queue.shift
+		revisedVariables, checks, wipeout = revisedConstraint.revise
+		@log.debug("Revising constraint " + revisedConstraint.to_s + ", pruned " + revisedVariables.join(", "))
+		@constraintChecks += checks
+		if wipeout
+		    if (violation + revisedConstraint.violationCost) <= @problem.maxViolation
+			constraints -= revisedConstraint
+			violation += revisedConstraint.violationCost
+			@log.debug("Discarding constraint " + revisedConstraint.to_s +
+			    ", cost " + revisedConstraint.violationCost.to_s)
+			@constraintsQueue << [ constraints,
+					       violation ]
+			wipeout = false
+			revisedVariables.each { |var| var.domain.undoPruning }
+		    else
+			revisedVariables.each { |var| revisedDomains << var.domain }
+			break
+		    end
+		else
+		    revisedVariables.each { |var|
+			revisedDomains << var.domain
+			constraints.notAllAssignedWithVariable(var).each { |constraint|
+			    queue << constraint unless queue.include?(constraint) or constraint == revisedConstraint
+			}
+		    }
+		end
+	    end
+	    return revisedDomains, wipeout, constraints, violation
+	end
+    end
+end

data/lib/Domain.rb

@@ -0,0 +1,100 @@
+#!/usr/bin/ruby
+
+require 'set'
+
+module ConstraintSolver
+    # This class represents the domain of a variable, i.e. a set of values that
+    # can be assigned to the variable.
+    class Domain
+	attr_reader :values, :undoStack
+	# Initialises a new domain. Optionally, a set of initial values can be
+	# given.
+	def initialize(values=nil)
+	    if not (values.nil? or values.kind_of?(Set))
+		raise ArgumentError, "Values must be a set!"
+	    end
+	    @values = values.nil? ? Set.new : values
+	    @undoStack = Array.new
+	end
+
+	# Adds value to the domain.
+	def <<(value)
+	    @values << value
+	end
+
+	# Deletes value from the domain.
+	def delete(value)
+	    @values.delete(value)
+	end
+
+	def size
+	    @values.size
+	end
+
+	def first
+	    @values.entries[0]
+	end
+
+	def include_any?(enum)
+	    @values.include_any?(enum)
+	end
+
+	def each
+	    @values.each { |value|
+		yield value
+	    }
+	end
+
+	def sort(&block)
+	    @values.sort(&block)
+	end
+
+	def collect(&block)
+	    values.collect(&block)
+	end
+
+	def empty?
+	    @values.empty?
+	end
+
+	# Prunes the values from the domain.
+	def prune(values)
+	    if not values.kind_of?(Set)
+		values = Set.new([ values ])
+	    end
+	    @undoStack.push(@values)
+	    @values -= values
+	    if @values.empty?
+		raise DomainWipeoutException
+	    end
+	end
+
+	# Undoes pruning by replacing the current list of values with the one
+	# before the last time prune was called.
+	def undoPruning
+	    if @undoStack.empty?
+		raise UndoStackEmptyException, "No more prunes to undo!"
+	    end
+	    @values = @undoStack.pop
+	end
+
+	def include?(value)
+	    @values.include?(value)
+	end
+
+	def to_s
+	    "{" + @values.entries.join(", ") + "}"
+	end
+
+	def ==(domain)
+	    return false unless domain.kind_of?(Domain)
+	    (@values == domain.values) and (@undoStack == domain.undoStack)
+	end
+    end
+
+    class UndoStackEmptyException < Exception
+    end
+
+    class DomainWipeoutException < Exception
+    end
+end

data/lib/GraphUtils.rb

@@ -0,0 +1,293 @@
+#!/usr/bin/ruby
+
+require 'set'
+require 'extensions'
+
+module GraphUtils
+    # Represents a bipartite graph.
+    class BipartiteGraph
+	attr_reader :x
+	attr_accessor :e, :y
+	# First argument to the constructor is the first set of values, second
+	# argument is the second set. The third argument is a hash which maps
+	# elements from the first set to an array of elements from the second
+	# set, designating edges (adjancency list).
+	def initialize(x, y, e)
+	    unless x.kind_of?(Set) and y.kind_of?(Set) and e.kind_of?(Hash) and
+		not x.empty? and not y.empty? and not e.empty?
+		raise ArgumentError,
+		    "Two non-empty sets of values and a hash where key => [value] designates edges must be given!"
+	    end
+	    @x = x
+	    @y = y
+	    @e = e
+	    @max_matching = nil
+	end
+
+	# algorithm to compute maximum matching in O(\sqrt{V} E) taken from
+	# Perl package Graph::Bipartite
+	def maximum_matching
+	    @e_double = @e.dup
+	    @e.each_key { |k|
+		@e[k].each { |v|
+		    if not @e_double.has_key?(v)
+			@e_double[v] = Set.new
+		    end
+		    @e_double[v].add(k)
+		}
+	    }
+	    matching = Hash.new
+	    @e_double.each_key { |key|
+		matching[key] = nil
+	    }
+	    if @max_matching.nil?
+		recalc = true
+	    else
+		recalc = false
+		@max_matching.each { |k,v|
+		    if not @e[k].include?(v)
+			recalc = true
+		    else
+			# recompute the new matching based on the old matching
+			matching[k] = v
+			matching[v] = k
+		    end
+		}
+	    end
+	    if recalc
+		level = Hash.new
+		while sbfs(matching, level) > 0
+		    sdfs(matching, level)
+		end
+		@max_matching = matching.delete_if { |k,v| @y.include?(k) or v.nil? }
+	    end
+	    return @max_matching
+	end
+
+	# Computes a mapping from x value to a set of y values. Each mapping
+	# designates an arc which can be removed because it doesn't belong to
+	# any matching. The method requires a matching as an argument.
+	def removable_values(matching)
+	    edges = Array.new
+	    label = Hash.new 
+	    @e.each_key { |k|
+		@e[k].each { |v|
+		    if matching.has_key?(k) and matching[k] == v
+			edge = DirectedEdge.new(k, v)
+			edges << edge
+			label[edge] = :used
+		    else
+			edges << DirectedEdge.new(v, k)
+		    end
+		}
+	    }
+
+	    # edges in strongly connected components
+	    GraphUtils::strongly_connected_components(@x | @y, edges).each { |component|
+		componentHelper = Hash.new
+		component.each { |i| componentHelper[i] = 1 }
+		(edges.select { |edge|
+		    componentHelper.has_key?(edge.startVertex) and componentHelper.has_key?(edge.endVertex)
+		}).each { |edge|
+		    label[edge] = :used
+		}
+	    }
+
+	    # edges traversed during breadth-first search for m-alternating
+	    # paths starting at m-free vertices
+	    ((@x - matching.keys) + (@y - matching.values)).each { |vertex|
+		GraphUtils::find_paths(vertex, edges).each { |edge|
+		    label[edge] = :used
+		}
+	    }
+
+	    pruneMap = Hash.new
+	    (edges.delete_if { |edge| label.has_key?(edge) }).each { |edge|
+		if not pruneMap.has_key?(edge.endVertex)
+		    pruneMap[edge.endVertex] = Set.new
+		end
+		pruneMap[edge.endVertex].add(edge.startVertex)
+	    }
+
+	    return pruneMap
+	end
+
+	private
+
+	def sbfs(matching, level)
+	    stack1 = Array.new
+	    stack2 = Array.new
+	    @x.each { |x|
+		if matching[x].nil?
+		    level[x] = 0
+		    stack1 << x
+		else
+		    level[x] = -1
+		end
+	    }
+	    @y.each { |y|
+		level[y] = -1
+	    }
+	    while not stack1.empty?
+		stack2.clear
+		free = nil
+		while not stack1.empty?
+		    x = stack1.pop
+		    @e_double[x].each { |y|
+			if matching[x] != y and level[y] == -1
+			    level[y] = level[x] + 1
+			    stack2 << y
+			    free = y if matching[y].nil?
+			end
+		    }
+		end
+		if not free.nil?
+		    return 1
+		end
+		stack1.clear
+		while not stack2.empty?
+		    y = stack2.pop
+		    @e_double[y].each { |x|
+			if matching[y] == x and level[x] == -1
+			    level[x] = level[y] + 1
+			    stack1 << x
+			end
+		    }
+		end
+	    end
+
+	    return 0
+	end
+
+	def sdfs(matching, level)
+	    @x.each { |x|
+		if matching[x].nil?
+		    rec_sdfs(matching, level, x, nil)
+		end
+	    }
+	end
+
+	def rec_sdfs(matching, level, x, y)
+	    if y.nil?
+		@e_double[x].each { |y|
+		    if (matching[x] != y) and (level[y] == level[x] + 1)
+			if rec_sdfs(matching, level, nil, y) == 1
+			    matching[x] = y
+			    matching[y] = x
+			    level[x] = -1
+			    return 1
+			end
+		    end
+		}
+		level[x] = -1
+	    else
+		if matching[y].nil?
+		    level[y] = -1
+		    return 1
+		else
+		    @e_double[y].each { |x|
+			if (matching[y] == x) and (level[x] == level[y] + 1)
+			    if rec_sdfs(matching, level, x, nil) == 1
+				level[y] = -1
+				return 1
+			    end
+			end
+		    }
+		end
+		level[y] = -1
+	    end
+	    return 0
+	end
+    end
+
+    # Represents a directed edge in a graph.
+    class DirectedEdge
+	attr_reader :startVertex, :endVertex
+    	def initialize(startVertex, endVertex)
+	    @startVertex = startVertex
+	    @endVertex = endVertex
+	end
+
+	def include?(v)
+	    v == startVertex or v == endVertex
+	end
+
+	def ==(edge)
+	    edge.kind_of?(DirectedEdge) and @startVertex == edge.startVertex and @endVertex == edge.endVertex
+	end
+
+	def to_s
+	    @startVertex.to_s + " -> " + @endVertex.to_s
+	end
+    end
+
+    class << self
+	# Performs a breadth-first traversal of the graph given by the list of
+	# edges starting at startVertex.
+	# Returned is the list of edges that were traversed.
+	def find_paths(startVertex, edges)
+	    arcs = Set.new
+	    edgeQueue = edges.find_all { |edge| edge.startVertex == startVertex }.to_set
+	    while not edgeQueue.empty?
+		currentEdge = edgeQueue.find { |i| true }
+		edgeQueue.delete(currentEdge)
+		arcs.add(currentEdge)
+		nextEdges = edges.find_all { |edge| edge.startVertex == currentEdge.endVertex }
+		edgeQueue.merge(nextEdges.delete_if { |edge| arcs.include?(edge) })
+	    end
+
+	    return arcs.to_a
+	end
+
+	# Computes the strongly connected components in a graph given by its
+	# edges. The first argument is a set of nodes in the graph, the second
+	# argument is a list of directed edges.
+	# Returned is an array of strongly connected components, each one an array
+	# of nodes in the component.
+	# Algorithm due Robert Tarjan (1972).
+	def strongly_connected_components(nodes, edges)
+	    edge_cache = Hash.new
+	    nodes.each { |node|
+		edge_cache[node] = Array.new
+	    }
+	    edges.each { |edge|
+		edge_cache[edge.startVertex] << edge
+	    }
+	    retval = Array.new
+	    nodeQueue = nodes.dup
+	    while not nodeQueue.empty?
+		retval += tarjan(nodeQueue.find { |i| true }, nodeQueue, edge_cache, [], 0, {}, {})
+	    end
+
+	    return retval
+	end
+
+	private
+
+	def tarjan(node, nodeQueue, edges, stack, distance, distances, lowlink)
+	    retval = Array.new
+	    distances[node] = distance
+	    lowlink[node] = distance
+	    stack << node
+	    nodeQueue.delete(node)
+	    edges[node].each { |e|
+		distance += 1
+		v = e.endVertex
+		if nodeQueue.include?(v)
+		    retval = tarjan(v, nodeQueue, edges, stack, distance, distances, lowlink)
+		    lowlink[node] = lowlink[v] if lowlink[v] < lowlink[node]
+		elsif stack.include?(v)
+		    lowlink[node] = distances[v] if distances[v] < lowlink[node]
+		end
+	    }
+	    if lowlink[node] == distances[node]
+		nodes = stack.slice!(stack.index(node), stack.size)
+		if nodes.size > 1
+		    retval << nodes
+		end
+	    end
+
+	    return (retval.nil? ? nil : retval.compact)
+	end
+    end
+end