1. Artificial Intelligence
Practical 2: Forward Checking
Ian Gent

2. Artificial Intelligence
Practical 2: Forward Checking
Part I : Overview
Part II: Three ways to implement FC
Part III: Other parts of the practical
Part IV: What I’m looking for

3. Practical 2: Forward Checking
Write a program to implement the two algorithms BT (Backtracking) and FC (Forward Checking.) Perform an empirical comparison of the two algorithms.
Some practical stuff:
This is practical 2 of 2.
Each will carry equal weight, I.e. 10% of total credit
You may use any implementation language you wish
Deadline(s) are negotiable (can be decided after vacation)

4. Aims and Objectives Aims: Objectives:
to give experience in implementing important AI search algorithms
to give experience in comparing AI techniques empirically
Objectives:
after completing the practical, you should have:
implemented the algorithms BT and FC
gained an appreciation of some of the basic techniques necessary
performed and reported on an empirical comparison of different algorithms

5. What you need to do Implement BT and FC for binary CSP’s
if you can do FC you can do BT
FC is the hard bit
implement at least two (static) heuristics for each
Implement a reader to read in benchmark CSP’s
format of problems will be provided
use benchmarks for testing
Perform empirical comparison of algorithms
run on benchmark problems
report on comparative success of algorithm/heuristic combinations

6. What you can get away with
Implement BT binary CSP’s
implement at least one heuristics
Implement a reader to read in benchmark CSP’s
format of problems will be provided
use benchmarks for testing
Perform empirical comparison of algorithms
run on benchmark problems
report on success or otherwise
Don’t expect too many marks for doing the above
but don’t expect zero either

7. Three Ways to Implement FC
You only need one implementation!
Choose the style that suits you and the language you like using
Three ways are:
using the general search algorithm
recursive
from pseudocode using specific data structures

8. Implementing FC (1)
You can implement FC using the generic search algorithm presented earlier
Search states = some representation of current assignment of values to variables, and current domains for each variable
Forward checking done when new states created
Do search by depth-first
Main problem is memory management
not letting space expand endlessly/overwriting existing states
easier if you’ve got GC built in
Appropriate for languages with non destructive data structures (e.g. Lisp, Haskell)

9. FC via general search algorithm
1. Form a one element list with null state
null state = state with no decisions = original CSP
2. Loop Until (either list empty or we have a solution)
Remove the first state S from the list
Choose the next decision to make
which variable x to assign next
Create a new state for each possible choice of decision
decisions are all remaining values v in Dx
to create each new state, assign x=v and forward check
MERGE the set of new states into the list
3. If (solution in list) succeed and report solution
else list must be empty, so fail

10. Implementing FC (2) Functional languages are good for search
e.g. Lisp, Haskell
Write propagator for forward checking which makes non destructive changes.
I.e. original state still exists, but we get a new one for free
GC done for you
Write search function recursively
handles the manipulation of the list for you via the function calling stack

11. Implementing FC (2) Search (CSP): choose var
while (value remains in CDvar)
Call Search( fc-propagate(CSP[var = value]))
If call succeeds with solution, return solution
If all calls failed, return failure

12. Implementing FC(3) Follow implementation outlined by Prosser
Avoids most memory management problems
Explicit data structures initially set up
when we remove values from vi to vj we modify them
reductions[j] contains sequence of sequence
each one a sequence of values disallowed by past var
past-fc[j] is a set of variables
set of variables i which caused value removals from vj
future-fc[i] is another set
set of variables in which the current value of vi causes value removals

13. General pseudocode for bcssp
Procedure bccsp (n, status)
consistent := true, status := unknown, ii := 1
while (status = unknown)
if (consistent)
ii := label(ii,consistent)
need special purpose function fc-label here
else ii := unlabel(ii,consistent)
and fc-unlabel here
if (ii > n)
status := solution
else if (ii = 0)
status := impossible

14. Implementing FC(3.2) Use data structure suggested by Bacchus/van Run
Have a 2D array Domain[ii,k]
first dimension is variables, second dimension values
Domain[ii,k] = 0 if value k still possible for variable ii
I.e. if k still belongs to CD[ii]
If value k impossible, removed from CD[ii]
Domain[ii,k] = j, where j is variable that caused removal
On backtracking, to undo effect of assigning j
if Domain[ii,k] = j, reset it so that Domain[ii,k] = 0
either store all changes made by j, or just iterate over 2D array looking for those equal to j
when we remove values from vi to vj we modify them
reductions[j] contains sequence of sequence
each one a sequence of values disallowed by past var
past-fc[j] is a set of variables
set of variables i which caused value removals from vj
future-fc[i] is another set
set of variables in which the current value of vi causes value removals

15. Other parts of the practical
Input format:
the APES group has a standard format for sharing binary CSP’s.
Allows sharing of benchmarks
Valuable for testing (all programs should give same results)
Write a reader for this format
translate input to your internal format for CSP
your representation of variables, domains, constraints
create small test problems for yourself
and if you want, share them for others

16. Heuristics I am only looking for static variable ordering heuristics
implement dynamic ones if you wish
heuristics are harder in Prosser’s version
see paper by Bacchus & van Run for pointers
Heuristics you might consider
lexicographic, v1, v2, v3…
random, v17, v16, v2, v19 …
min degree: var involved in least constraints first
max degree: var involved in most constraints first
other heuristics you find/can think of

17. Empirical Report
Run your program(s) against benchmark instances I will provide, and others you might want to try
From empirical evidence, how do the techniques perform?
Is FC better than BT? Worse? varies across problems?
Are there some problems that you can’t solve in reasonable cpu time?
Is min degree better than max degree?
Are some problems harder than others?

18. Empirical Report Write a report on your experiments
Describe the purpose of each experiment, the results, and conclusions you draw
Try to make it a good piece of empirical AI!
Include results as e.g. tables or graphs
as appendix if too many results
Probably a few pages

19. What I am looking for A correct functioning program
speed is not important (within reason)
should implement at least 4 combinations of algorithm/heuristic
A report summarising program and empirical work
no set word limit, probably needs a few pages to present good empirical work well
evidence that your code is correct
e.g. sample output, correct result on benchmarks
conclusions on your empirical result
code (electronically if it’s HUGE)

20. Additional Issues Some ways to get more credit …
create/find problems for which usually worse algorithm/heuristic does better
think of different heuristics
think of interesting hypotheses and test them
implement FC so that propagation causes a chain reaction.
I.e. if you get domain size = 1, redo FC from there
Since I’ve asked for static heuristics, we may search on variable x, domain size 4, when variable y has d.s. = 1
implement dynamic variable ordering heuristics

21. Some pointers A tutorial on constraint programming
Barbara Smith
Leeds University, 1995
Hybrid Algorithms for the Constraint Satisfaction Problem
Patrick Prosser
Computational Intelligence, 1993
Dynamic Variable Ordering in CSPs
Bacchus & van Run
CP95, 1995