Artificial Intelligence - Methods for Solving CSPs

---

---

Constraint Satisfaction problems (CSP) is a mathematical problem defined by a set of variables, their possible values (domain), and constraints that limit the ways in which the values can be combined.

CSPs has methods to systematically investigate possible solutions while avoiding dead end paths in order to solve efficiently. Following are various methods to solve CSPs −

• Backtracking Algorithm

• Forward-Checking Algorithm

• Constraint Propagation Algorithms

• Local Search

Backtracking Algorithm

Backtracking is a deep-first search method, which is a recursive algorithm for solving problems that require searching for solutions in a structured space. It checks all possible sequences of decisions, stopping when it detects a solution or determines that no solution exists.

The approach tries to construct a solution slowly, adding one variable at a time. When it determines that the current solution cannot be stretched into a valid solution, it "backtracks" the previous decision by trying with a different value.

We can improve backtracking by choosing the variable with the most constraints. The idea is to deal with the most "tough" or "sensitive" variables first. The backtracking algorithm has the following components −

• Variable Ordering: Choosing which variable to assign a value to next in the search process is called variable ordering. Picking the right order can make the algorithm work much better.

  For instance, in Sudoku, if we start solving variables with the smallest number of available choices (almost negligible variables), we will decrease the number of decisions that we need to do for the rest of the variables. The idea is called Minimum Remaining Values or MRV which means we need to solve first variables with the least number of valid options.

• Value Ordering: Once we have determined which variable to assign (Variable Ordering), we must choose which value from its domain to test first. The order in which we assign values also influences the performance of the algorithm.

  For instance, in a map coloring problem, assigning a color which causes the least conflict between neighbor regions is a smoother search, and this is known as Least Constraining Value (LCV) heuristic, where we try values that leave the most flexibility for other variables.

Working of Backtracking Algorithm

Following are the steps for Backtracking Algorithm −

• Step 1: Assign a value to the variable based on the problems constraints.

• Step 2: After assigning a value, check if the current assignment is valid based on the constraints.

• Step 3: Move to the next variable and repeat the process.

• Step 4: If assigning a value violates a constraint or leads to no valid solutions, undo the assignment (backtrack) and try with different value.

• Step 5: Continue until a solution is found or all possibilities have been exhausted.

Advantages

This approach has the following advantages −

• It is easy to implement for many problems.

• Works for a wide variety of problems by changing the constraints.

• It guarantees finding a solution if one exists.

Limitations

Despite its strengths, backtracking has certain drawbacks −

• For large problems, it may take too long as it explores many possible paths.

• It may repeatedly explore the same invalid paths without optimization.

Forward-Checking Algorithm

In order to solve a CSP, we use search algorithms that assign values to variables one at a time; however, limitations may make certain assignments incorrect. Forward-Checking (FC) is a technique used during this search process to avoid wasting time on invalid assignments.

Forward checking is an algorithmic reduction technique that minimizes the domains of unassigned variables immediately after assigning a value to a variable. This is achieved by comparing constraints between assigned and unassigned variables. The constraint violates if any value in the domain of an unassigned variable matches with the allocated variables then that value will be removed.

Working of Forward-Checking Algorithm

Following are the steps for Forward checking algorithm −

• Choose a variable, and assign to it a value.

• Look at the constraints between the assigned variable and all other unassigned variables.

• Remove values from the domains of unassigned variables if they violate the constraint.

• If any unassigned variables domain becomes null, backtrack immediately (because no solution is possible with the current assignment).

Advantages

The forward-checking method has following advantages −

• Reduces the size of the search space by removing inconsistent values first.

• Detects dead ends earlier than the backtracking algorithm.

• Increases efficiency in numerous CSPs.

Limitations

However, forward-checking has certain limitations that can affect its effectiveness −

• Forward-checking only examines one step ahead, therefore it may still investigate improper paths where constraints between unassigned variables are violated. When combined with techniques such as constraint propagation (e.g., arc consistency), all constraints are maintained consistently.

Constraint Propagation Algorithms

Constraint propagation is a strategy that solves CSPs by reducing variable's possible values or domains by successively applying a set of constraints.

Unlike forward-checking, which checks one step forward, constraint propagation ensures that all possible constraints between any connected variables are consistent by modifying the domains of all pairs rather than just immediate ones.

This technique gradually eliminates the choices of each variable, which makes the problem easier to solve by eliminating wrong choices early. It encourages consistency throughout the task and prevents the algorithm from following wrong paths, saving time and computing effort.

The common methods that are used in constraint propagation are described below −

Arc Consistency

This method ensures that any value of one variable corresponds to a valid value in another related variable −

• Step 1: Start with a CSP problem, including the variables, their domains, and constraints between variables.

• Step 2: Iterate over all arcs of constraints among variables. Verify that every value in the domain of one variable maps to a consistent value in the domain of the other variable.

• Step 3: When an inconsistency is found, delete the incorrect values from the first variable's domain and check the affected arcs.

• Step 4: Repeat this process until all arcs are consistent or a domain becomes empty, which indicates the need to backtrack and revise previous assignments.

Node consistency

This method make sure that individual variables meet the constraints applied to them. When a value in a variable's domain violates a constraint, it is removed. For example, if a meeting room is not large enough for a team, remove it from the list of options.

Path consistency

This method checks triples of variables and ensures that the relations among them are consistent. For example, if X = 1 and X + Y = Z, then path consistency ensures the domain for Z has valid numbers based on X and Y.

Advantages

Constraint propagation has these benefits −

• This method reduces variable domains, making it easier to identify a solution.

• Detects inconsistencies early as compared to other algorithms, hence saving time and money.

Limitations

This method has following disadvantages −

• If the problem is large, complex and has many variables and constraints this method will be slow.

• May not fully solve the problem and often needs to be go back to complete the process.

Local Search

Local Search is a problem-solving method that involves researching the "neighborhood" of possible solutions. It does not search the entire solution space but starts with an initial solution and improves it gradually by making minor changes.

The objective is to find a good enough solution rather than exhaustively searching for the perfect one, which makes it suitable for huge and complex problems. Let us understand Local Search by using an example −

• This example is about class scheduling, let us begin with an random schedule which assigns classes to the time slots and rooms, even in case of conflicts.

• Class A: Room 1, 9:00 AM, class B: Room 1, 9:00 AM (Conflict: same room and time) and class C: Room 2, 10:00 AM

• Minimize conflicts in scheduling for example no two classes should have the same room at the same time.

• Reschedule by shifting one class to a different room or time slot. For instance: Shift Class B to Room 2 at 9:00 AM.

• Find the conflicts in the current schedule. In our case conflicting is class B. Shift it to a new room or time that reduces conflicts.

• We can end this when all conflicts have been resolved, such that no classes overlap, or a time limit is reached.

Advantages

Local search methods has the following benefits for solving CSPs −

• Works well for large, complex problems.

• Quickly finds "good enough" solutions.

• Easy to implement and understand.

Limitations

Despite its advantages, local search has a few drawbacks −

• In local search, the algorithm might find a solution that seems good, but it's not the best possible. It might stop searching once it finds a "good enough" solution, missing the best one.

• Local search methods need to be adjusted for each problem, as what works for one may not work for another.