Abstract:
A system for solving a dynamic constraint satisfaction problem comprises a constraint network of variables and constraints. The system creates a first sub-problem model that includes a first model type, one or more first variables and zero or more first constraints. The system propagates the first constraints through the constraint network and determines if a first conflict is detected from propagating the first constraints. If the first conflict is detected, the system restores the constraint network variables to a first previous state before the first constraints were propagated. The system creates a first sub-problem set that includes a second model type and one or more sub-problem models. The system connects the first sub-problem model to the first sub-problem set via a second constraint and propagates the second constraint through the constraint network.

Description:
FIELD OF THE INVENTION 
     One embodiment is directed generally to a computer system, and in particular to a constraint based computer system that solves dynamic constraint satisfaction problems. 
     BACKGROUND INFORMATION 
     Many of the tasks that are addressed by decision-making systems and artificial intelligence systems can be represented as constraint satisfaction problems (“CSP”s). In this representation, the task is specified in terms of a set of variables, each of which can assume values in a given domain, and a set of constraints that the variables must simultaneously satisfy. The set of variables, domains and constraints is referred to as a CSP. Each constraint may be expressed as a relation, defined over some subset of the variables, denoting valid combinations of their values. A solution to a CSP is an assignment of a value to all the variables from their respective domains that satisfies all of the constraints. 
     A constraint based system includes a constraint solver that attempts to find one or more solutions to a given CSP, or prove that no solution exists. Constraint based systems are used for many artificial intelligence related applications and a variety of other applications, including: (1) Product configurators; (2) Robotic control; (3) Temporal reasoning; (4) Natural language processing; (5) Spatial reasoning; (6) Test-case generation for software and hardware systems; (7) Machine vision; (8) Medical diagnosis; (9) Resource allocation; and (10) Frequency allocation. 
     The network of constraints in a CSP can be viewed as a graph, having a node for each variable and “arc” for each constraint. The members of each arc are the variables that appear in the constraint to which the arc corresponds. An arc is said to be consistent if for any variable of the arc, and any value in the domain of the variable, there is a valid assignment of values to the other variables on the arc that satisfies the constraint represented by the arc. 
     Classes of problems exist which are comprised of very large sets of variables that may only be conditionally related or required for a solution. One example of such problems is the configuration of large component-based systems. For example, selecting a type of hard disk controller for a computer configuration is not needed if a hard disk has not been chosen as a form of storage. If instead flash memory is chosen, a different set of variables and constraints would be required to be solved. Known CSP solvers do not allow the representation of conditional structure or reasoning over an inclusion of a variable in a solution. Techniques have been developed to allow such large problems to be represented as a set of smaller sub-problems, conditionally related through composition or association. A “dynamic constraint satisfaction problem” is one in which these sub-problems of variables and constraints can be incrementally added as required, either explicitly or as a result of inference from the propagation of constraints. 
     One known approach to minimize large CSP problems is referred to as “Conditional CSP”, and includes the notion of a variable being active or inactive, as well as constraints to activate a variable. In this approach, a variable is only assigned a value in the final solution if it is active. Conditional CSP is limited in that it does not provide any significant space savings in large problems, nor does it allow for segmentation of related variables into sub-problems. Another known approach is referred to as “Generative CSP” and extends Conditional CSP by introducing the concept of components, which are groups of related variables, and component type, which is the further extension and specialization of these components. However, similar to Conditional CSP, Generative CSP is still implemented in terms of activity state and does not provide real space savings. 
     SUMMARY OF THE INVENTION 
     One embodiment is a system for solving a dynamic constraint satisfaction problem that comprises a constraint network of variables and constraints. The system creates a first sub-problem model that includes a first model type, one or more first variables and zero or more first constraints. The system propagates the first constraints through the constraint network and determines if a first conflict is detected from propagating the first constraints. If the first conflict is detected, the system restores the constraint network variables to a first previous state before the first constraints were propagated. The system creates a first sub-problem set that includes a second model type and one or more sub-problem models. The system connects the first sub-problem model to the first sub-problem set via a second constraint and propagates the second constraint through the constraint network. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  is a block diagram of a dynamic constraint based system that can implement an embodiment of the present invention. 
         FIG. 2   a  is an example of a CSP model definition for a television component type “TV” in accordance to one embodiment. 
         FIG. 2   b  is a CSP model definition for a “Home Theater” type in accordance to one embodiment. 
         FIG. 3  is an example of a type hierarchy for a television in accordance with one embodiment. 
         FIG. 4  is a data structure diagram that illustrates the composition of a sub-problem variable in accordance with one embodiment. 
         FIG. 5  is a data structure diagram that represents the composition of a sub-problem set variable in accordance with one embodiment. 
         FIG. 6  is a flow diagram of the functionality of the dynamic constraint solver when a choice is made in the constraint model in accordance with one embodiment. 
         FIG. 7  is a flow diagram of the functionality of the dynamic constraint solver when creating/instantiating an encapsulated sub-problem and connecting it to the base/primary problem. 
     
    
    
     DETAILED DESCRIPTION 
     One embodiment is a dynamic constraint based system that models a problem as a Constraint Satisfaction Problem by defining sub-problems and encapsulating the sub-problem variables and constraints. The system instantiates the encapsulated sub-problems and adds them to the primary problem, thus extending the set of variables in the solution without having to restart the system to redefine the problem. 
       FIG. 1  is a block diagram of a dynamic constraint based system  10  that can implement an embodiment of the present invention. System  10  includes a bus  12  or other communication mechanism for communicating information, and a processor  22  coupled to bus  12  for processing information. Processor  22  may be any type of general or specific purpose processor. System  10  further includes a memory  14  for storing information and instructions to be executed by processor  22 . Memory  14  can be comprised of any combination of random access memory (“RAM”), read only memory (“ROM”), static storage such as a magnetic or optical disk, or any other type of computer readable media. System  10  further includes a communication device  20 , such as a network interface card, to provide access to a network. Therefore, a user may interface with system  10  directly, or remotely through a network or any other method. 
     Computer readable media may be any available media that can be accessed by processor  22  and includes both volatile and nonvolatile media, removable and non-removable media, and communication media. Communication media may include computer readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism and includes any information delivery media. 
     Processor  22  is further coupled via bus  12  to a display  24 , such as a Liquid Crystal Display (“LCD”), for displaying information to a user. A keyboard  26  and a cursor control device  28 , such as a computer mouse, is further coupled to bus  12  to enable a user to interface with system  10 . 
     In one embodiment, memory  14  stores software modules that provide functionality when executed by processor  22 . The modules include an operating system  15  that provides operating system functionality for system  10 . The modules further include a dynamic constraint solver module  16  that performs dynamic constraint solving as disclosed in more detail below. System  10  can be part of a larger system that includes a constraint solver, such as a product configurator or artificial intelligence system. Therefore, system  10  will typically include one or more additional functional modules  18  to include the additional functionality. 
     In one embodiment, a problem to be solved is modeled as a CSP. The CSP model definition may include variables that further encapsulate an optional, type-abstracted CSP sub-problem. Embodiments ensure that a minimal required set of variables is present in the system, and include methods to expand or reduce the set of variables as required by the solution. 
       FIG. 2   a  is an example of a CSP model definition  202  for a television component type “TV” in accordance to one embodiment. Model definition  202  includes a list of variables (e.g., size, weight, etc.) and the domains for each variable (e.g., for “size” the domain is the range of 19-70, for “wall-mountable” the domain is “false” or “true”). An example of a constraint of model definition  202  is “Televisions weighing more than 175 pounds cannot be wall-mounted”. Model definition  202  is a CSP model that includes all variables and constraints required to model the properties of a television. 
     Model definition  202  may be used as a defined sub-problem model for another CSP model. For example,  FIG. 2   b  is a CSP model definition  204  for a “Home Theater” type. Model definition  204  includes a variable “Video Screen” which is defined as an instance of the sub-problem TV defined by model definition  202  as indicated by the “TV” within the curly brackets. Model definition  204  further includes constraints. An example of a constraint for model definition  204  is “Seating distance is at least twice the screen size”. 
     In one embodiment, the sub-problem type is further abstracted to group explicit types into an inheritance hierarchy that provides efficient reasoning, similar to object oriented programming. Abstracting common features of two types, “A” and “B”, into a common super type “C” means that these features are now described without redundancy. On the individual component level, type abstraction also allows efficient reasoning. For example, for a given point in time if it is not clear whether type A or B will be advantageous for a certain component, then the common properties and constraints represented by C can already be used to prune the search space, without precluding any choice. A child type inherits all variables and constraints of its parent type, and can add additional variables and constraints. 
     Type abstraction represents a hierarchy of abstract types and concrete types. An abstract type in the hierarchy possesses the set of properties that correspond to the intersection of all properties of its subtypes. For example, after a component has been assigned an abstract type “t”, its type assignment will later need to be refined to a subtype of t either by the constraint solver explicitly choosing that variable for refinement, or because filtering removes other subtypes of t from consideration. A valid final assignment (to be part of a solution) will then be the assignment of a concrete type. 
       FIG. 3  is an example of a type hierarchy for a television in accordance with one embodiment. “Television” class  300  represents a “super” type class that includes a “Projection” class  301  and a “Flat-Panel” class  302 . Flat-panel class  302  includes an “LCD” class  304  and a “Plasma” class  305 . Concrete types  306 - 311  are the specific models of televisions that can be chosen with the Television type (e.g., PR-50, LC42, etc.). Since, for example, LCD class  304  and Plasma class  305  are subclasses of Flat-Panel class  302 , they can each have different properties. For example, LCD class  304  may have properties regarding a type of backlighting that would not apply to plasma televisions, while Plasma class  305  may have properties regarding a type of gas that would not apply to LCD televisions. 
     In one embodiment, dynamic constraint solver  16  utilizes the hierarchical structure of  FIG. 3  to provide an encapsulation of a set of sub-problem variables and constraints into a single variable. In dynamic structured problems, there may be two types of structures defined through different problem set variables. One type represents a composition relationship to sub-problems. The other type represents an association relationship to peer problem instances. The dynamic structure allows for efficient management of the variables and constraints related to a given sub-problem.  FIG. 4  is a data structure diagram  400  that illustrates the composition of a sub-problem variable in accordance with one embodiment. As shown in diagram  400 , the single sub-problem variable includes the model type (e.g., the “Television” type of  FIG. 3 ), one or more variables, and zero or more constraints. Data structure diagram  400  is an actual encapsulation of the sub-problem elements into a single variable as opposed to the virtual grouping that is done in known CSP systems. 
     In one embodiment, dynamic constraint solver  16  provides a sub-problem set variable that represents a set of optional sub-problem variables. This allows a sub-problem to be both conditionally and multiply instantiated in the solution.  FIG. 5  is a data structure diagram  500  that represents the composition of a sub-problem set variable in accordance with one embodiment. The sub-problem set includes a model type (e.g., the “Television” type of  FIG. 3 ) and a set of zero or more sub-problem variables (e.g., the sub-problem variable of  FIG. 4 ) of the given type. As an example, for the model type “Home Theater” of  FIG. 2   b , the variable “AV Component” is an optional and multi-instantiable sub-problem set because it has a domain cardinality of 0.6. 
     In one embodiment, dynamic constraint solver  16  instantiates an encapsulated sub-problem, and adds it to the primary problem, thereby extending the set of variables in the solution. This is done in a manner that avoids the necessity of restarting and redefining the problem as is required by many prior art solvers. In one embodiment, a constraint problem to be solved by dynamic constraint solver  16  is modeled as a constraint network that includes a node for each variable in the problem and an edge between the nodes for each constraint in the problem. A choice of a value for a variable can be made by a user or through some other means. For example, if the problem is for a product configurator, a user makes a choice when interacting with the configurator model. The user choice may be a representation of an action by the user in the configurator user interface (“UI”). Examples of a user choice include clicking a checkbox, entering a number in a box, choosing a number or choice within a drop down box, etc. The user choices (or choices made in any other manner) are added and managed in a manner that allows for efficient backtracking and/or negation. 
       FIG. 6  is a flow diagram of the functionality of dynamic constraint solver  16  when a choice is made in the constraint model in accordance with one embodiment. In one embodiment, the functionality of the flow diagram of  FIG. 6 , and  FIG. 7  below, is implemented by software stored in memory or other computer readable or tangible medium, and executed by a processor. In other embodiments, the functionality may be performed by hardware (e.g., through the use of an application specific integrated circuit (“ASIC”), a programmable gate array (“PGA”), a field programmable gate array (“FPGA”), etc.), or any combination of hardware and software. 
     At  602 , the choice is received and stored. The choice can be stored using any type of internal representation of the choice and in one embodiment is stored in memory  14 . The choice at  602  may cause one or more associated outward constraints in the constraint network to be affected (i.e., due to the propagation of the choice throughout the constraint network), which may modify the associated node for each constraint. 
     At  604 , the first/next outward constraint affected by the choice at  602  is evaluated. 
     At  606 , it is determined if the nodes for the constraint have changed. If so, at  608  the previous state for each changed nodes is stored and associated with the added choice at  602 . 
     At  610 , if the nodes for the constraint have not changed, or after storing the previous state at  608 , it is determined if there are additional constraints to evaluate from the choice. If there are, the flow returns to  604 . In this manner, the propagation of the entire constraint network as a result of the choice  602  is evaluated and the previous state of any nodes that have changed in response to the choice is saved. 
     When the functionality of  FIG. 6  is complete, for each node affected by propagation in the constraint network, the prior domain state is recorded and is associated with the current choice. In one embodiment, dynamic constraint solver  16  instantiates an encapsulated sub-problem, and adds it to the primary problem, thereby extending the set of variables in the solution. Because the prior domain state has been recorded/stored, this is done in a manner that avoids the necessity to restart and redefine the problem as is required by prior art constraint solver systems. Further, dynamic constraint solver  16  views the sub-problem set as including all possibilities from the beginning when adding a sub-problem. Therefore, adding a sub-problem is reducing rather than expanding the problem, which also avoids the need for restarting.  FIG. 7  is a flow diagram of the functionality of dynamic constraint solver  16  when creating/instantiating an encapsulated sub-problem and “connecting” (i.e., through an association relationship or a composition relationship) it to the base/primary problem. 
     At  702 , a “container” for the encapsulation of the sub-problem instance variable is created. 
     At  704 , the sub-problem type is associated with a variable. As disclosed above, a sub-problem variable has a type such as the “TV” type of  FIG. 2   a.    
     At  706 , sub-problems variables are created within the sub-problem instance. For example, the TV type of  FIG. 2   a  has variables “Size”, “Weight”, etc. 
     At  708 , sub-problem constraints are created within the sub-problem instance. At this point, all information needed for the data structure diagram  400  of  FIG. 4  that represents the sub-problem variable has been assembled. 
     At  710 , the sub-problem constraints are propagated and consistency-checked on the constraint network. The propagation at  710  is an initial consistency checking of the sub-problem constraints to establish their starting state, given the runtime state of the CSP problem. Therefore, the functionality of  FIG. 6 , starting at  604 , is executed when each constraint is propagated. The propagation at this point is limited to the sub-problem variable to reduce the amount of computing necessary. 
     At  712 , it is determined if a conflict is detected as a result of the propagation of the constraint. 
     If a conflict is detected at  712 , at  718  the prior state of the nodes is restored so that the state of the network reverts to its state prior to the creation and propagation of the constraints. Because the functionality of  FIG. 6  was executed, the prior state has been recorded and associated with the current constraint before the constraint was propagated. At  720 , the failure of the sub-problem addition is reported. 
     If no conflict was detected at  712 , at  714  the constraint connecting the sub-problem to the base problem is added and propagated and the sub-problem set of  FIG. 5  is successfully instantiated. In one embodiment, connecting the sub-problem to the base problem is similar to storing an arbitrary association of a component to structure in a CSP solver. In one embodiment, the association of the base problem and the sub-problem is stored in memory  14 . 
     At  716 , it is determined if a conflict is detected as a result of the propagation of the constraint. If a conflict is detected, the functionality continues at  718  where the previous state of the nodes is restored. 
     Because of the functionality of  FIG. 7 , dynamic constraint solver  16  can revert the sub-problem instantiation, thereby ensuring efficient backtracking. Because the sub-problem variables and constraints are encapsulated within the sub-problem instance variable, and the sole connection to the base problem is via a connection constraint, removing the instance becomes a simple matter of removing the connection constraint. The sub-problem can then either be discarded, or retained for future reuse. Without the connection to the base problem, it is no longer considered part of the solution. 
     Dynamic constraint solver  16  provides multiple methods for creating and connecting a dynamic sub-problem. In one embodiment, the sub-problem set of  FIG. 5  provides application programming interface methods or user interfaces which allow a user to explicitly create an instance of a given sub-problem type, as well as a method to create a connection between the sub-problem instance and the sub-problem set. For example, a button may be displayed on a user interface that allows a user to select “add a TV”. This may result in the TV sub-problem to be added to a home entertainment problem set, with the associated constraints and variables. 
     In another embodiment, dynamic constraint solver  16  provides a method of implicitly creating and connecting in the solution a dynamic sub-problem by reasoning over the cardinality of the containing set variable. The sub-problem set of  FIG. 5  includes among its properties a cardinality, which is a reflection of the number of members within the set. The cardinality of the sub-problem set can be reasoned over by constraints as any numeric variable. As an example, for SubProblemSet.card( ).gt(0), adding a numeric constraint enforcing that the cardinality of the “SubProblemSet” variable is greater than 0 may lead to the automatic addition of sub-problem variables to the set. 
     In another embodiment, dynamic constraint solver  16  provides a method of implicitly creating and connecting in the solution a dynamic sub-problem by reasoning over the abstract component type of the containing set variable. The sub-problem set of  FIG. 5  includes among its properties a type, which is a reflection of the type or family of types of the sub-problem variables within the set. The type of the sub-problem set can be reasoned over by constraints as any variable. As an example, for Video_Screen.is Type(PL52), using the variables and types disclosed in  FIGS. 2   a ,  2   b  and  3  above, specifying that the “Video Screen” may only be of type “PL52” will cause an instance of a sub-problem variable of type “PL52” to be created within the “Video Screen” set. 
     As disclosed, embodiments allow a sub-problem to be dynamically added or deleted from a sub-problem set. Therefore, a CSP can be solved efficiently because the minimal set of variables/nodes are present in the constraint network. 
     Several embodiments are specifically illustrated and/or described herein. However, it will be appreciated that modifications and variations of the disclosed embodiments are covered by the above teachings and within the purview of the appended claims without departing from the spirit and intended scope of the invention.