Optional Assignment 1
Programming Assignment - Planning & Bayesian Networks
Task 1 (CSE 4308: 50 Points; CSE 5360: 50 points)
The task in this programming assignment is to design appropriate
descriptions of facts, actions, and goals, using the PDDL language,
for two planning problems: the Tower
of
Hanoi problem, and the 7-puzzle problem (a variation of the
8-puzzle problem where two squares are clear instead of one). You will
use your descriptions as inputs to a Graphplan implementation. If your
descriptions are correct, Graphplan will produce appropriate plans.
Compiling and Running the Software
The Graphplan software can be downloaded from graphplan.zip.
See
the README file in that package for additional information. To compile
the software on omega, unzip the directory, and,
from that directory, type
make graphplan
Once the program compiles, it can be invoked from the commandline as
follows:
graphplan -o [operators_file] -f [facts_file]
For example:
graphplan -o block_ops.txt -f block_facts3.txt
- Argument operators_file specifies the
location of a text file containing definitions of actions. For example,
see block_ops.txt
for definitions of actions appropriate for the blocks world.
- Argument facts_file specifies the
location of a text file containing definitions of facts about the
environment, including objects (and types for those objects), general
predicates that are always true, initial state description, and goal
description. For example, see block_facts2.txt, block_facts3.txt,
and block_facts4.txt
for example fact descriptions for the blocks world.
Once you start running the software, it will ask you three questions.
Just hit enter for each
question, so as to use the default settings. If
your descriptions of actions and facts are correct, the program will
print out a plan achieving the stated goal.
Note that the preconds in each fact file will contain both
statements that are always true in that domain (i.e., in the Tower of
Hanoi domain or the 7-puzzle domain), and statements that simply
describe the initial state for that specific planning problem. In
addition to the facts files for the specific planning problems you are
given, you will have to create a separate text file that includes all
the statements that must be present in ANY facts file for that domain.
Tower of Hanoi Description
A description of the Tower of Hanoi domain can be found at Wikipedia.
In all problems that your program will be tested with there will be
five discs (called disk1, disk2, disk3, disk4, disk5) and three pegs
(called A, B, C). In all your facts files you will have to include both
a common part (defining objects and relations among objects) and a
plan-specific part (describing the initial state and goal for each
plan). Note that some of the five disks may not appear in some of the
planning problems.
The two planning problems you have to solve are:
Problem 1
initial state:
(on disk1 disk2)
(on disk2 A)
(clear disk1)
(clear B)
(clear C)
goal:
(on disk1 B)
(on disk2 C)
Problem 2
initial state:
(on disk1 disk2)
(on disk2 disk3)
(on disk3 disk4)
(on disk4 disk5)
(on disk5 C)
(clear disk1)
(clear A)
(clear B)
goal:
(on disk1 disk2)
(on disk2 disk3)
(on disk3 disk4)
(on disk4 disk5)
(on disk5 A)
7-puzzle Description
7-puzzle is like 8-puzzle, except that there are only pieces numbered
from 1 to 7 (not from 1 to 8), and there are two clear squares on the
board. At any move, we can move a numbered piece to an adjacent clear
square.
The two planning problems you have to solve are (X indicates
a clear square):
Problem 1
initial state:
123
456
7XX
goal:
123
X56
4X7
Problem 2
initial state:
XX7
654
321
goal:
123
456
7XX
Grading
This task will be graded for 50 points. Half the points will
correspond to your solutions for the Tower of Hanoi world, and the rest
will correspond to your solutions for the 7-puzzle problem.
Specifically, the point allocation is:
- 20 points: defining facts and actions correctly. The
language that you define (i.e., the actions, objects, and general
statements that are always true) should be sufficient not only for the
specific plans that you are required to construct, but also for any
other planning problems that we can define in the Tower of Hanoi domain
or the 7-puzzle domain. As part of grading, we will also test your
solutions on planning problems that we will make up.
- 30 points: solving the planning problems
you
are given (two for the Tower of Hanoi domain, two for the 7-puzzle
domain) + 1 additional problem per domain. You get 5 points for each
problem. If you solve all 6
correctly, you get 30 points.
Task 2 (CSE 4308: 50 Points; CSE 5360: 50 points)
Figure 1: A Bayesian network establishing
relations between events on the burglary-earthquake-alarm domain,
together with complete specifications of all probability distributions.
For the Bayesian network of Figure 1, implement a program that
computes and prints out the probability of any combination of events
given any other combination of events. If the executable is called
bnet, here are some example invocations of the program:
- To print out the probability P(Burglary=true and
Alarm=false | MaryCalls=false).
bnet Bt Af given Mf
- To print out the probability P(Alarm=false and
Earthquake=true).
bnet Af Et
- To print out the probability P(JohnCalls=true and
Alarm=false | Burglary=true and Earthquake=false).
bnet Jt Af given Bt Ef
- To print out the probability P(Burglary=true and
Alarm=false and MaryCalls=false and JohnCalls=true and
Earthquake=true).
bnet Bt Af Mf Jt Et
In general, bnet takes 1 to 6(no more, no fewer) command line
arguments, as follows:
- First, there are one to five arguments, each argument
specifying a variable among Burglary, Earthquake, Alarm, JohnCalls, and
MaryCalls and a value equal to true or false. Each of these arguments
is a string with two letters. The first letter is B (for Burglary), E
(for Earthquake), A (for Alarm), J (for JohnCalls) or M (for
MaryCalls). The second letter is t (for true) or f (for false). These
arguments specify a combination C1 of events whose probability we want
to compute. For example, in the first example above, C1 =
(Burglary=true and Alarm=false), and in the second example above C1 =
(Alarm=false and Earthquake=true).
- Then, optionally, the word "given" follows, followed by one
to four arguments. Each of these one to four arguments is again a
string with two letters, where, as before the first letter is B (for
Burglary), E (for Earthquake), A (for Alarm), J (for JohnCalls) or M
(for MaryCalls). The second letter is t (for true) or f (for false).
These last arguments specify a combination of events C2 such that we
need to compute the probability of C1 given C2. For example, in the
first example above C2 = (MaryCalls=false), and in the second example
there is no C2, so we simply compute the probability of C1, i.e.,
P(Alarm=false and Earthquake=true).
The implementation should not contain hardcoded values for all
combinations of arguments. Instead, your code should use the tables
shown on Figure 1 and the appropriate formulas to evaluate the
probability of the specified event. It is OK to hardcode values from
the tables on Figure 1 in your code, but it is not OK to hard code
values for all possible command arguments, or probability values for
all possible atomic events. More specifically, for full credit, the
code should include and use a Bayesian network class. The class should
include a member function called computeProbability(b, e, a, j, m),
where each argument is a boolean, specifying if the corresponding event
(burglary, earthquake, alarm, john-calls, mary-calls) is true or false.
This function should return the joint probability of the five events.
Other Instructions
- Your implementation can be in C, C++, Java or Python. They
should only use the base versions of the language (No Addl Packages)
- Please include a readme.txt file that has:
- Name and UTA ID of the student.
- What programming language is used.
- How the code is structured.