[BLANK_AUDIO].
A logic program is a collection of
sentences that define relations.
Either directly by enumeration, or
indirectly, in the form of logical rules.
Here's a simple example.
And the first four sentences here define
the parent relation by enumeration.
Art is parent of Bob, and Amy is the
parent of Bob.
Bob is the parent of Coe and Cal.
The rule in the middle, defines the
grandparent relation in terms of the
parent relation.
X is the grandparent of Z If X is a parent
of some person Y and Y is a parent of Z.
So we shall see, given these definitions
of parenting, grandparent, we can
conclude that Art and Amy are both the
grandparents of Cal and Coe.
As previously mentioned, GDL has a logic
programming languages, in many
ways resembles Prolog, the most popular of
the logic programming languages.
Moreover, there're several important
differences.
First of all, the semantics of GDL is
purely declarative.
That is, there's no imperative features,
such as
assert and retract and cut, as in Prolog.
Second, GDL has some restrictions that
ensure that all pertinent questions are
decidable.
In particular, all relations can be
computed in finite time.
And finally, there's some reserved words
which tailor
the language to the task of defining
games.
Despite these restrictions we frequently
use the phrase logic
program to refer to a game description in
GDL.
Logic programs in GDL are built up from 4
disjoint classes of symbols.
Namely, object constants, function
constants, relation constants and
variables.
And what follows, we write such symbols as
strings of letters,
digits and a few non alpha numeric
characters such as underscore.
Constants must begin with a lowercase
letter or digit,
variables must begin with an uppercase
letter.
The arity of a function constant or a
relation constant is the number
of arguments that can be associated with
the function or relation when writing
expressions.
As we'll see in the example to follow.
A term is defined as either an
object constant, a variable, or a
functional term.
And by functional term here, I mean an
expression consisting
of an N-Ary function constant, and N
simpler terms.
And what follows, we write
functional terms and traditional
mathematical notation.
The function constant first, followed by
its
arguments, enclosed in parentheses and
separated by commas.
Now for example, if F is a unary
function constant, and G is a binary
function constant.
If A and B are both object constants, and
if X is a variable,
then f of a is a functional term, and so
is g of X,b.
An atom is an expression consisting of n
re relation
constant and n terms.
What follows,
we write atoms in traditional mathematical
notation, just like terms.
The relation constant, in this case.
Followed by it's arguments,
enclosed in parentheses, and separated by
commas.
For example, if p is a binary relation
constant.
And if a and b are object constants, then
p of ab is an atom.
A negation is an expression formed using
the
negation sign, the tilde character and an
app.
For example, not p of ab.
A
literal is either an atom or a negation.
An atom by itself is sometimes called a
positive
literal and a negation is sometimes called
a negative literal.
Finally we get to rules.
A rule is an expression consisting of a
distinguished atom called the head and a
conjunction of zero or more literals
called
the body, separated by the colon minus
operator.
Literals in the body are called subgoals.
Intended meaning, is that an instance of
the head is true,
and ever corresponding instances of all of
the positive subgoals are true.
And all of the negative subgoals are
false.
A logic program in GDL is a finite
collection of atoms and rules, this for.
In order to simplify our definitions in
analysis,
we occasionally talk about infinite sets
of rules.
While these sets are useful, they're not
themselves logic programs.
Okay, here are some examples of things
that are logic programs.
In this first case, we define the parent
relation
p in terms of father f and mother m.
X is the parent
of Y if X is a father of Y.
X is also a parent of Y if X is a mother
of Y.
In the second example, we defined
grandparent
in terms of parent, as we saw before.
In the third, we define ancestor in terms
of parent.
Note that the definition in this case is
recursive.
And finally, we define remote ancestors.
Any ancestors that is not apparent using
the not symbol.
Although every GDL expression's a finite
set of atoms and rules,
not every finite set of atoms and rules is
a GDL description.
As mentioned earlier, there are some
restrictions
to ensure that such descriptions have
desirable properties.
The
first of these restrictions is called
Safety.
A rule in a logic program is safe if
and only if every variable that appears in
the head,
or, in any negative literal in the body
also
appears in at least one positive literal
in the body.
The first rule shown here is safe.
Variables X and Z appear in the head, and
Y appears in a negative subgoal.
Fortunately, all three
of these variables appear in positive
subgoals as well.
And so the rule is safe.
The second is not safe because variable Z
appears
in the head but not in any positive
subgoal.
And the third rule is not safe because the
variable Z appears in a negative subgoal
but not in a positive subgoal.
In GDL we require that all rules are safe.
The next two restrictions in GL have to do
with recursion.
The restrictions are best be-defined using
this notion of dependency graphs
illustrated here.
The dependency graph for a set of rules is
a directed
graph in which the nodes are the relations
mentioned in the head.
And, heads and bodies of the rules.
And there's an arc from a node p to a node
q, whenever p occurs with the body
of a rule in which q is in the head.
A
set of rules is recursive if and only if
its dependency graph contains a cycle, as
this one does.
Now we use, we say that a recursion in a
set of rules is stratified, if and only
if a variable in a subgoal relation occurs
in
a subgoal with a relation at a lower
stratum.
The recursion in the first rule shown here
is
stratified because all the variables
involved in the recursion.
Occurring relations that are not defined
in terms of r.
Recursion in the second rule is not
stratified because the
variables involved in the recursion do not
appear in other relations.
In GDL, we require that all recursions be
stratified.
[SOUND].
Another case is stratified negation.
A negation in a set of rules is said to be
stratified, if
and only if there's no recursive cycle in
the dependency graph involving a negation.
For example, the first rule set shown here
is not
stratified, because there's a cycle
involving a negative occurrence of R.
By contrast, the second of rules,set of
rules is stratified.
The set is recursive, but there's no
negation occurring in a cycle.
The only negative occurrence of our
[UNKNOWN]
definition of T, and that's not part of
any recursion.
In GDL, we also require that all negations
be stratified.
Okay, now with these three definitions
behind us we could formalize
the semantics and in other words the
meaning of GDL expressions.
Start with the notion of a Herbrand
Universe.
Herbrand Universe is the set of all ground
terms in the language.
In case of language without function
constants, the Herbrand
Universe is exactly the set of all object
constants.
In the presence of function constants, we
add in the functional terms that can be
formed using those function constants.
Since nested functional terms are
forbidden in
GDL, the Herbrand universe is always
finite.
The Herbrand base for a logic program is
the set of all ground atoms that can
be formed from the relation constants in
the
language and the elements of a Herbrand
Universe.
For example, given the language shown
here, the Herbrand
Base consists of six atoms and just six
atoms.
P of a.
P of b.
Q of aa, q of ab, q of ba, and q of bb.
That's it, there are no more.
A Herbrand interpretation is a arbitrary
subset of the Herbrand Base for a program.
Dutifully, we can think of the Herbrand
interpretation as
a listing of the atoms that are true in
that interpretation with a sense that
those that are
not in the interpretation are considered
to be false.
Given the Herbrand Base we just saw, here
are three different interpretations.
Since there are six atoms in Herbrand
Base,
there're two to the sixth, or 64, distinct
interpretations.
Here we've just listed three of them.
Okay.
Now, finally, we say that interpretation
delta satisfies
an expression, in our language, under the
following conditions.
If
[INAUDIBLE]
is a ground atom, delta satisfies it, if
and only if
[INAUDIBLE]
is in delta.
Is a member of that set.
Delta satisfies not
[INAUDIBLE]
if and only if
[INAUDIBLE]
is not in delta.
Delta satisfies
[INAUDIBLE]
1 and
[INAUDIBLE]
2.
And so forth, if and only it satisfies
every
[INAUDIBLE]
I.
Finally, delta satisfies a rule if and
only if
it satisfies the head, or fails to satisfy
the body.
Or equivalently, delta satisfies a rule if
and only
it satisfies a head whenever it satisfies
the body.
And finally we say that delta satisfies a
rule with variables, which
is a common case, if and only it satisfies
every ground instance.
That is, every instance with members
of the broad universe substituted for
variables.
Now, in general a logic program can have
more than one model.
Consider the program consisting of p of
a,b and the rule of q of x,y if p of x,y.
This program has one model of just p of
a,b and q of a,b.
And it has another model with p of a,b and
q of
a,b and q of b,a and it has other models
as well.
However, it's worth noting that the first
model is the subset of the second.
And it's
clear that p of a and q of a, b must be
true in any model of this program.
But q of b, a is optional.
To eliminate such ambiguities, we usually
adopt
a minimal model semantics for logic
workups.
A model D, of a program that's minimal, if
null, if
no proper subset of D is also a model of
that program.
One interesting property of our language
is that
every logic program has a unique minimal
model.
Also all models are finite.
Okay, that's it for traditional ordinary
logic programs.
logic programs like these are often
defined as closed in that
they fix the meaning of all the relations
in their program.
In open logic programs, some of the
relations called the inputs, are left
undefined.
And other relations, usually called the
outputs.
Are
[COUGH]
excuse me, are defined in terms of these.
the same program can be used with
different
input relations yielding different output
relations in each case.
So, formally now, we, to find an open
logic program as a logic
program, together with a partition of the
relation constants in these two types.
Input relations and output relations.
Output relations can appear anywhere in
the program, but input relations can
appear only in the sub roles of rules, not
in their heads.
but base for an open logic program is, is
the set of all atoms that can
be formed from the base relations of the
program, and the entities in the programs
combined.
Universe.
An input model is an arbitrary subset of
its input base.
The output base for an open logic program
is the set of all atoms that can
be formed from the output relations of the
program and the entities in the program
around universe.
And an output model is some subset of its
output base.
Even an open logic program.
P and an input model D, we define the
overall model for responding to D
to be the minimum model of P together with
D, in other words, P union D.
The output model corresponding to D is the
intersection
of the overall model with the program's
output base.
In other words, it consists of those
sentences in
the overall model that mention only the
output relations.
And finally
we can think of the meaning of open logic
programs of function
that maps each input model for the program
into the corresponding output model.
for example, the simple logic program
shown
here gives different outputs for different
inputs.
Given p of a, b and p of b, b, and q of b,
the output is r of a, b.
Given just p of a, b and p of b, b,
without q of
b, the output is r of a, b and r of b, b
both.
Okay, now, with those definitions behind
us, let's get back to game description.
As mentioned in the introduction, we can
conceptualize a game
as a structured state graph, like the one
shown here.
GDL gives us a way of describing such
graphs in compact form.
The content of a structured state graph
can be
expressed in GDL, using some reserved game
independent vocabulary.
The vocabulary is game-independent and the
same
words are used in describing all games.
There are ten game-independent
relation constants in GDL, anyway the ones
requested here.
For example, role of A means that A has a
role in the game.
Base of the p, base of proposition means
that p is a proposition in the game,
action of a inputs are input of role and a
means that a is in action in the game 4
rule, the specified role.
Init of p means that the proposition p is
true in the initial state.
True if p means that the proposition p is
true in the current state.
Whatever that happens to be, we'll see
later.
Does of r and a means that the player
performs, r performs action a in the
current state.
Again we'll see how that works out later.
Next of p means that the proposition p is
true
in the next state, the one after the
current state.
Legal of r and
a means that it's legal for role r to play
action a in the current state.
Goal of r and n means that the player in,
in the current state has utility n.
Terminal means that the current state is a
terminal state, the game is over.
GDL has no independent, game independent
function constants.
However, there are 101 independent, game
independent object constants in GDL.
Namely the base ten representations of the
integers from zero through 100 inclusive.
0, 1, 2, 3, 4 and so forth, up to 100.
These are included mostly as utility
values for game
states, with zero being low and 100 being
high.
the first step in writing a game
description is to select
the game specific vocabulary to capture
the structure of states and actions.
For example, here we have object constants
white and
black as names for the two roles of the
game.
We use A, B, and C to refer to primitive
entities in the game.
We have names p and q for relationships
among primitive entities, and we
have f and g as operations that can be
performed on these primitive entities.
Finally, we have some helper relations, r
and s.
The propositions comprising states can be
thought of as either object
constants or functional terms in our
language formed using the relationship
functions.
similarly, actions can be either object
constants
or functional terms form using action
factions.
For example, supplying relationships
functions p and q to primitive
objects.
Applying them to primitive
[INAUDIBLE]
a, b, and c, we end up with propositions p
of a and q of b, c.
And applying operations f and g to these
objects.
We end up with actions like f of a and g
of b,c and so forth.
The rules in the game description say
which propositions are
true, and which actions are performed as
shown in what follows.
And specify the results of the performing
those actions.
Finally, we define a game description as
an open logic programming using GDL's game
independent vocabulary together with the
game's game
specific vocabulary subject to a few
restrictions here.
True and does our input relations to the
program.
The GDL game description must get complete
definitions for role, action, base, and
input.
I'm sorry, an init.
it must define legal and goal in terms of
an input relation true.
It must define next in terms of input true
and does.
Since does and true are treated as inputs,
there, there're must
not be any rules with either of those
relations in the head.
Okay, well, wow.
That's a lot to digest.
in the abstract is concepts are difficult
to
master, and as presented, they're not
particularly well-motivated.
In practice, things are a lot simpler.
In the next couple of segments, we
illustrate these notions by looking at,
Plus games, specific game description and
see how it's used in simulating a game.