Deductive

Deductive Databases
Outline
• What is a deductive database system?
• Some basic concepts
• Basic inference mechanism for logic programs
• Datalog programs and their evaluation
Deductive Databases
• What is a deductive database system?

A deductive database can be defined as an advanced
database augmented with an inference system.
Deductive
Database + Inference
database
By evaluating rules against facts, new facts can be derived, which in turn
can be used to answer queries. It makes a database system more powerful.
Deductive Databases
• Some basic concepts from logic

To understand the deductive database system well, some
basic concepts from mathematical logic are needed.
- term
- n-ary predicate
- literal
- (well-formed) formula
- clause and Horn-clause
- facts
- logic program
Deductive Databases
- term
A term is a constant, a variable or an expression
of the form f(t1, t2, ..., tn), where t1, t2, ..., tn are
terms and f is a function symbol.
- Example: a, b, c, f(a, b), g(a, f(a, b)), x, y,
g(x, y)
- n-ary predicate
An n-ary predicate symbol is a symbol p
appearing in an expression of the form p(t1, t2, ..., tn),
called an atom, where t1, t2, ..., tn are terms. p(t1, t2, ...,
tn) can only evaluate to true or false.
- Example: p(a, b), q(a, f(a, b)), p(x, y)
Deductive Databases
- literal
A literal is either an atom or its negation.
- Example: p(a, f(a, b)), p(a, f(a, b))
- (well-formed) formula
- A well-formed (logic) formula is defined
inductively as follows:
- An atom is a formula.
- If P and Q are formulas, then so are P,
(PQ), (PQ), (PQ), and (PQ).
- If x is a variable and P is a formula containing
x, then (xP) and (xP) are formulas.
Deductive Databases
- clause
- A clause is an expression of the following
form:
A1  A2  ...  An  B1  ...  Bm
where Ai and Bj are atoms.
- The above expression can be written in the
following equivalent form:
consequent B1  ...  Bm  A1  ...  An
antecedent
or
B1, ..., Bm  A1 , ..., An
Deductive Databases
- clause
A B A  B A B BA
1 1 1 1 1 1
0 1 1 0 1 1
1 0 0 1 0 0
0 0 1 0 0 1
- Horn clause
A Horn clause is a clause with the head containing only
one positive atom.
Bm  A1 , ..., An
Deductive Databases
- fact
- A fact is a special Horn clause of the following
form:
B
with all variables in B being instantiated. (B 
can be simply written as B.)
- logic program
A logic program is a set of Horn clauses.
Deductive Databases
- Example (a logic program)
Facts:
james
supervise(franklin, john),
supervise(franklin, ramesh),
supervise(franklin, joyce) franklin jennifer
supervise(james, franklin),
supervise(jennifer, alicia),
supervise(jennifer, ahmad),
john ramesh joyce alicia ahmad
supervise(james, jennifer).
Rules:
superior(X, Y)  supervise(X, Y),
superior(X, Y)  supervise(X, Z), superior(Z, Y),
subordinary(X, Y)  superior(Y, X).
Deductive Databases
Facts can be considered as the data stored as relations in a

relational database.
Deductive Databases
• Basic inference mechanism for logic programs

- interpretation of programs (rules + facts)
There are two main alternatives for interpreting the theoretical
meaning of rules:
proof theoretic, and
model theoretic interpretation
- proof theoretic interpretation

1. The facts and rules are considered to be true statements,
or axioms.
facts - ground axioms
rules - deductive axioms
2. The deductive axioms are used to construct proofs that
derive new facts from existing facts.
Deductive Databases
- Example:
1. superior(X, Y)  supervise(X, Y). (rule 1)

2. superior(X, Y)  supervise(X, Z), superior (Z, Y). (rule 2)
3. supervise(jennifer, ahmad). (ground axiom, given)

4. supervise(james, jennifer). (ground axiom, given)
5. superior(jennifer, ahmad). (apply rule 1 on 3)

6. superior(james, ahmad). (apply rule 2 on 4 and 5)
Deductive Databases
- model theoretic interpretation

1. Given a finite or an infinite domain of constant values,
assign to each predicate in the program every possible
combination of values as arguments.
2. All the instantiated predicates contitute a Herbrand base.
3. An interpretation is a subset of the Herbrand base.
4. In the Herbrand base, each instantiated predicate evaluates
to true or false in terms of the given facts and rules.
5. An interpretation is called a model for a specific set of rules
and the corresponding facts if those rules are always true
under that interpretation.
6. A model is a minimal model for a set of rules and facts if
we cannot change any element in the model from true to
false and still get a model for these rules and facts.
Deductive Databases
- Example:
2. superior(X, Y)  supervise(X, Z), superior(Z, Y). (rule 2)
known facts:
supervise(franklin, john), supervise(franklin, ramesh),
supervise(franklin, joyce), supervise(james, franklin),
supervise(jennifer, alicia), supervise(jennifer, ahmad),
For all other possible (X, Y) combinations supervise(X, Y) is false.
domain = {james, franklin, john, ramesh, joyce, jennifer, alicia, ahmad}

Deductive Databases
Interpretation - model - minimal model

known facts:
derived facts:
superior(franklin, john), superior(franklin, ramesh),
superior(franklin, joyce), superior(jennifer, alicia),
superior(jennifer, ahmad), superior(james, franklin),
superior(james, jennifer), superior(james, john),
superior(james, ramesh), superior(james, joyce),
superior(james, alicia), superior(james, ahmad).
For all other possible (X, Y) combinations superior(X, Y) is false.
Deductive Databases
The above interpretation is also a model for the rules (1) and (2) since each
of them evaluates always to true under the interpretation. For example,
superior(X, Y)  supervise(X, Y)
superior(franklin, john)  supervise(franklin, john) is true.

superior(franklin, ramesh)  supervise(franklin, ramesh) is true.
... …
superior(X, Y)  supervise(X, Z), superior(Z, Y)
superior(james, ramesh)  supervise(james, franklin),

superior (franklin, ramesh) is true.
superior(james, alicia)  supervise(james, jennifer),
superior (jennifer, alicia) is true.
Deductive Databases
The model is also the minimal model for the rule (1) and (2) and the
corresponding facts since eliminating any element from the model
will make some facts or instatiated rules evaluate to false.
For example,
eliminating supervise(franklin, john) from the model will make this fact
no more true under the interpretation;
eliminating superior (james, ramesh) will make the following rule no

more true under the interpretation:
superior(james, ramesh)  supervise(james, franklin),

superior(franklin, ramesh)
Deductive Databases
- Inference mechanism
In general, there are two approaches to evaluating logical
programs: bottom-up and top-down.
- Bottom-up mechanism
(also called forward chaining and bottom-up resolution)
1. The inference engine starts with the facts and applies
the rules to generate new facts. That is, the inference
moves forward from the facts toward the goal.
2. As facts are generated, they are checked against the
query predicate goal for a match.
Deductive Databases
- Example
query goal: superior(james, Y)?
rules and facts are given as above.
1. Check whether any of the existing facts directly matches the

query.
2. Apply the first rule to the existing facts to generate new facts.
3. Apply the second rule to the existing facts to generate new
facts.
4. As each fact is gnerated, it is checked for a match of the the
query goal.
5. Repeat step 1 - 4 until no more new facts can be found.
All the facts of the form: superior(james, a) are the answers.

Deductive Databases
- Example:
2. superior(X, Y)  supervise(X, Z), superior(Z, Y). (rule 2)
known facts:
domain = {james, franklin, john, ramesh, joyce, jennifer, alicia, ahmad}
superior(james, Y)?
applying the first rule: superior(james, franklin), superior(james, jennifer)

Y = {franklin, jennifer}
applying the second rule: Y = {John, Joyce, Ramesh, alicia, ahmad}

Deductive Databases
- Top-down mechanism
(also called back chaining and top-down resolution)
1. The inference engine starts with the query goal and
attempts to find matches to the variables that lead to
valid facts in the database. That is, the inference moves
backward from the intended goal to determine facts that
would satisfy the goal.
2. During the course, the rules are used to generate
subgoals. The matching of these subgoals will lead to
the match of the intended goal.
Deductive Databases
- Example
query goal: ?-superior(james, Y)
rules and facts are given as above.
Query: ?-superior(james, Y)
Rule1: superior(james, Y)  Rule2: superior(james, Y) 

supervise(james, Y) supervise(james, Z),
superior(Z, Y)
Y=franklin, jennifer
supervise(james, Z)
Z=frankiln Z=jennifer
superior(franklin, Y) superior(jennifer, Y)
Deductive Databases
Rule1: superior(franklin, Y)  Rule1: superior(jennifer, Y) 

supervise(franklin, Y) supervise(jennifer, Y)
Y= john, ramesh, joyce Y= alicia, ahmad

Deductive Databases

1. A Datalog program is a logic program.
2. In a Datalog program, each predicate contains
no function symbols.
3. A Datalog program normally contains two kinds
of predicates: fact-based predicates and rule-based
predicates.
fact-based predicates are defined by listing all the
combinations of values that make the predicate true.
Rule-based predicates are defined to be the head of one or
more Datalog rules. They correspond to virtual
relations whose contents can be inferred by the inference
engine.
Deductive Databases

Example:
- All the programs discussed earlier are
Datalog programs.
superior(X, Y)  supervise(X, Y).
superior (X, Y)  supervise(X, Z), superior (Z,
Y).
supervise(jennifer, ahmad).
- The following is a logic program, but not a

Datalog program:
p(X, Y)  q(f(Y), X)
Deductive Databases

two important concepts:
- safety of programs
- predicate dependency graph
Deductive Databases
- Safety of programs
A Datalog program or a rule is said to be safe if it
generates a finite set of facts.
- Condition of unsafty
A rule is unsafe if one of the variables in the rule can range
over an infinite domain of values, and that variable is not
limited to ranging over a finite predicate before it is
instantiated.
- Example:
big_salary(Y)  Y > 60000.
big_salary(Y)  Y > 60000, employee(X), salary(X,
Y).
Deductive Databases

- Example: ?-big_salary(Y)
big_salary(Y)  Y > 60000.
big_salary(Y)  Y > 60000, employee(X), salary(X,
Y).
The evaluation of these rules (no matter whether in
bottom- up or in top-down fashion) will never terminate.
The following is a safe rule:
big_salary(Y)  employee(X), salary(X, Y), Y >
60000.
Deductive Databases

A variable X is limited if
(1) it appears in a regular (not built-in) predicate in the body of
the rule.
(built-in predicates: <, >, , , =, )
(2) it appears in a predicate of the form X = c or c = X, where c
is a constant.
(3) it appears in a predicate of the form X = Y or Y = X in the
rule body, where Y is a limited variable.
(4) Before it is instantiated, some other regular predicates
containing it will have been evaluated.
- Condition of safty:
A rule is safe if each variable in it is limited.
A program is safe if each rule in it is safe.
Deductive Databases

- predicate dependency graphs
For a program P, we construct a dependency graph G
representing a refer to relationship between the predicates in P. This
is a directed graph where there is node for each predicate and
an arc from node q to node p if and only if the predicate q occurs
in the body of a rule whose head predicate is p.
Exampel:
superior(X, Y)  supervise(X, Y),
superior(X, Y)  supervise(X, Z), superior(Z, Y),
subordinary(X, Y)  superior(Y, X),
supervisor(X, Y)  employee(X), supervise(X, Y),
over_40K_emp(X)  employee(X), salary(X, Y), Y40000,
under_40K_supervisor(X)  supervisor(X), not(over_40K_emp(X)),
main_productx _emp(X ) employee(X), workson(X, productx, Y), Y  20,
president(X)  employee(X), not(supervise(Y, X)).
Deductive Databases

- predicate dependency graphs
supervisor under_40K_supervisor
 subordinate
main_poductx_emp president over_40K_emp superior


workson employee salary supervise
department project female male

Deductive Databases
Evaluation of nonrecursive rules

- If the dependency graph for a rule set has no cycles, the rule
set is nonrecursive.
Deductive Databases

- Evaluation of nonrecursive rules
- evaluation involving only fact-based predicates
?-salary(X, 60000)
$1 ($2 = “60000”(salary))
- evaluation involving only rule-based predicates

1. rule rectification
h(X, c)  ... h(X, Y)  ... ,Y=c
h(X, X)  ... h(X, Y)  ..., Y=X
Deductive Databases
•Datalog programs and their evaluation

- evaluation involving only rule-based predicate
2. Single rule evaluation
To evaluate a rule of the from:
p  p1, ..., pn
we first compute the relations corresponding to p1, ..., pn
and then the relation corresponding to p.
3. All the rules will be evaluated along the predicate
dependency graph. At each step, each rule will be evaluated
in terms of step (2).
Deductive Databases
- The general bottom-up evaluation strategy for a nonrecursive query
?-p(x1, x2, …, xn)
1. Locate a set of rules S whose head involves the predicate p. If there
are no such rules, then p is a fact-based predicate corresponding
to some database relation Rp; in this case, one of the following
expression is returned and the algorithm is terminated. (We use the
notation $i to refer to the name of the i-th attribute of relation Rp.)
(a) If all arguments in p are distinc variables, the relational
expression returned is Rp.
(b) If some arguments are constants or if the same variable
appears in more than one argument position, the expression
returned is
SELECT<condition>(Rp),
Deductive Databases
where the <condition> is a conjunctive condition made up of a

number of simple conditions connected by AND, and constructed as
follows:
i. if a constant c appears as argument i, include a simple
condition ($i = c) in the conjuction.
ii. if the same variable appears in both argument location j
and k, include a condition ($j = $k) in the conjuction.
2. At this point, one or more rules Si, i = 1, 2, ..., n, n > 0 exist with
predicate p as their head. For each such rule Si, generate a
relational expression as follows:
a. Apply selection operation on the predicates in the body for
each such rule, as discussed in Step 1(b).
b. A natural join is constructed among the relations that
correspond to the predicates in the body of the rule Si over the
common variables. Let the resulting relation from this join be Rs.
Deductive Databases
c. If any built-in predicate XY was defined over the
arguments X and Y, the result of the join is subjected to an
additional selection:
SELECT XY(Rs)
d. Repeat Step 2(c) until no more built-in predicates apply.
3. Take the UNION of the expressions generated in Step 2 (if more
than one rule exists with predicate p as its head.)
Deductive Databases
Evaluation of recursive rules

- If the dependency graph for a rule set has at least one cycle,
the rule set is recursive.
ancestor(X, Y)  parent(X, Y),
ancestor(X, Y)  parent(X, Z), ancestor(Z, Y).
- naive strategy
- semi-naive strategy
- stratified databases
Deductive Databases

- some teminology for recursive queries
- linearly recursive - left
linearly recursive ancestor(X, Y) 
ancestor(X, Z), parent(Z, Y) - right linearly recursive
ancestor(X, Y)  parent(X, Z),
ancestor(Z, Y)
- non-linearly recursive
sg(X, Y)  sg(X, Z), sibling(Z, W), sg(W, Y)
Deductive Databases

- extensional database (EDB) predicate
An EDB predicate is a predicate whose relation is stored in
the database - fact-based predicate.
- intensional database (IDB) predicate
An IDB predicate is a predicate whose relation is defined
by logic rules - rule-based predicate.
- Datalog equation
A Datalog equation is an equation obtained by replacing
“” and “” with “=” and “ ” in a rule, respectively.
a(X, Y) = p(X, Y)  X,Y(p(X, Z) a(Z, Y))
Deductive Databases

- fixed point
Consider a relation sequence: g0, g1, …, gi, gi+1, ...
g0 = ,
gi+1 = E(gi),
If there exits some g such that g = E(g), g is called the fixed point.
The least among all fixed points of E(...) is called the least fixed
point.
- evaluation of fixed points
If at some time we have E i(g0) = E i+1(g0),
E i(g0) = E (E( ... E(g0) ... )) then E i(g0) is the fixed point of the
i function E(...). It is also the least fixed
point of E(...).
Deductive Databases

- fixed point
Example:
a(X, Y) = p(X, Y)  X,Y(p(X, Z) a(Z, Y))
p = {(f, j), (f, r), (f, jo), (je, a), (je, ah), (ja, f), (ja, je)}
a0 = { }
a1 = {(f, j), (f, r), (f, jo), (je, a), (je, ah), (ja, f), (ja, je)}
a2 = {(f, j), (f, r), (f, jo), (je, a), (je, ah), (ja, f), (ja, je),
(ja, j), (ja, r), (ja, jo), (ja, a), (ja, ah)}
a3 = a2 least fixed point
The least fixed point of the above equation is also called the
transitive closure of p.
Deductive Databases

- evaluation of recursive queries
- naive strategy
1. The naive evaluation method is a bottom-up strategy
which computes the least model of a Datalog program.
2. It is an iterative strategy and at each iteration all rules are
applied to the set of tuples produced thus far to generate
all implicit tuples.
3. This iterative process continues until no more new tuples
can be produced.
Deductive Databases

- naive strategy
Consider the following equation system:
Ri = Ei(R1, ..., Ri, ..., Rn) (i = 1, ..., m)
which is formed by replacing the  symbol with an equality
sign in a Datalog program.
Algorithm Jacobi naive strategy
input: A system of algebraic equations and EDB. output:
The values of the variable relations: R1, ..., Ri, ..., Rn. for i = 1 to n do
Ri := ; repeat
Con := true;
for i = 1 to n do Si := Ri; for i = 1 to m do {Ri
:= Ei(S1, ..., Si, ..., Sn); if Ri  Si then
{Con := false; Si := Ri;}}
until Con = true;
Deductive Databases

- naive strategy
sg(X, Y)  sg(X, W), sibling(W, Z), sg(Z, Y)
sibling(X, Y)  parent(X, W), sibling(W, Z), parent(Y, Z)
sg(X, Y) = X,Y(sg(X, W) sibling(W, Z) sg(Z, Y))

sibling(X, Y) = X,Y(parent(X, W) sibling(W, Z) parent(Y, Z))
sg = E1(sg, sibling) sg R1
sibling = E2(sibling) sibling R2
R1 = E1(R1, R2)
R2 = E2(R2)
Deductive Databases

- naive strategy
Example:
ancestor(X, Y)  parent(X, Y),
ancestor(X, Y)  parent(X, Z), ancestor(Z, Y).
Parent = {(bert, alice), (bert, george), (alice, derek),
(alice, part), (derek, frank)}
bert
alice george
derek pat
frank
Deductive Databases

- naive strategy
Example:
A(X, Y) = X,Y(P(X, Z) A(Z, Y))  P(X, Y)
step 0: A0 = 
step 1: A1 = {(bert, alice), (bert, george), (alice, derek), (alice,
part), (derek, frank)}
part), (derek, frank), (bert, derek), (bert, pat), (alice,
frank)}
part), (derek, frank), (bert, derek), (bert, pat), (alice,
frank),
(bert, frank)}
step 4: A4 = A3
Deductive Databases

- naive strategy
Algorithm Gauss-Seidel naive strategy
Jacobi: Gauss-Seidel:
k-th iteration: k-th iteration:

R1(k) = E1(R1 (k-1), ..., Ri (k-1), ..., Rn (k-1)), R1(k) = E1(R1 (k-1), ..., Ri (k-1), ..., Rn (k-1)),
…… ……
Ri(k) = Ei(R1 (k-1), ..., Ri (k-1), ..., Rn (k-1)), Ri(k) = Ei(R1 (k), ..., Ri (k-1), ..., Rn (k-1)),
…… ……
Rn(k) = En(R1 (k-1), ..., Ri (k-1), ..., Rn (k-1)). Rn(k) = En(R1 (k), ..., Ri (k), ..., Rn (k-1)).
Deductive Databases

1. The semi-naive evaluation method is a bottom-up strategy.
2. It is designed to eliminate redundancy in the evaluation of
tuples at different iterations.
Let Ri(k) be the temporary value of relation Ri at iteration step k.
The differential of Ri between step k and step k - 1 is defined as
follows:
Di(k) = Ri(k) - Ri(k-1)
For a linearly recursive rule set, Di(k) can be substituted for Ri in
the k-th iteration of the naïve algorithm.
3. The result is obtained by the union of the newly obtained term
Ri and that obtained in the previous step.
Deductive Databases

Algorithm seminaiv strategy
input: A system of algebraic equations and EDB. output:
The values of the variable relations: R1, ..., Ri, ..., Rn.
for i = 1 to n do Ri := ; for i =
1 to m do Di := ; repeat
Con := true;
for i = 1 to n do {Di := E(D1, ..., Di, ..., Dn) - Ri;
Ri := Di  Ri; if Di 
 then Con := false; }
until Con is true;
Deductive Databases

Example:
Step 0: D0 = , A0 = ;
Step 1: D1 = P = {(bert, alice), (bert, george), (alice, derek), (alice, part),
(derek, frank)}
A1 = D1  A0 = {(bert, alice), (bert, george), (alice, derek), (alice,
part), (derek, frank)}
Step 2: D2 = {(bert, derek), (bert, pat), (alice, frank)}
part), (derek, frank), {(bert, derek), (bert, pat),
(alice, frank)}
Deductive Databases

Example:
Step 3: D3 = {(bert, frank)
part), (derek, frank), {(bert, derek), (bert, pat),
(alice, frank), (bert, frank)}
Step 3: D4 = .
The advantage of the semi-naive method is that at each step a differential term
Di is used in each equation instead of the whole Ri. In this way, the time
complexity of a computation is decreased drastically.
Deductive Databases

- The magic-set rule rewriting technique
motivation:
1. During a bottom-up evaluation, too many irrelevant tuples
are evaluated.
For example, to evaluate the query sg(john, Z)? using the
following rules:
sg(X, Y)  flat(X, Y),
sg(X, Y)  up(X, Z), sg(Z, W), down(W, Y),
a bottom-up method will generate all sg-tuples and then
makes a selection operation to the anwsers.
2. Using the constants appearing in the query to restrict
computation.
Deductive Databases

- The magic-set rule rewriting technique
sg(X, Y)  magic_sg(X) ,flat(X, Y),
sg(X, Y)  magic_sg(X), up(X, Z), sg(Z, W), down(W, Y),
ru les
Modified magic_sg(Z)  magic_sg(X), up(X, Z),
magic_sg(john).
le s
Magic ru
Two-phase evaluation:
1st phase: evaluate magic rules to generate a magic set.
2nd phase: evaluate modified rules, by which that magic
set is used to restrict the computation.
Deductive Databases

- Stratified databases
A stratified database is a Datalog program containing negated
predicates.
Example: Suppose that a supplier might wish to backorder items
that are not in the warehouse. It would be convenient to write:
backorder(X)  item(X), warehouse(X).
Its logically equivalent form is
backorder(X), warehouse  item(X).
But this rule has a different meaning : if X is an item, then
backorder it or it is stored in the warehouse. This is not what we
want.
Deductive Databases

- Prolblem: recursion via negation
p(X)  q(X),
q(X)  p(X).
- To avoid the recursion via negation, we introduce the concept
of stratification, which is defined by the use of a level l
mapping.
level l mapping: assign each literal in the program an integer
such that if
B  A1, …, An
and Ai is positive, then l(Ai)  l(B) for all i, 1  i  n. If Ai is
negative, then l(B) < l(Ai) for all i, 1  i  n.
Deductive Databases

- Prolblem: recursion via negation
p(X)  q(X),
q(X)  p(X).
- To avoid the recursion via negation, we introduce the concept
of stratification, which is defined by the use of a level l
mapping.
level l mapping: assign each literal in the program an integer
such that if
B  A1, …, An
and Ai is positive, then l(Ai)  l(B) for all i, 1  i  n. If Ai is
negative, then l(B) < l(Ai) for all i, 1  i  n.
Deductive Databases

- If you can assign integers to all the literals in a programusing
a level mapping, then this program is stratifiable.
p(X)  q(X),
q(X)  p(X).
In fact, we cannot find a level mapping for any program
which contains recursion via negation.
- Evaluation of a stratified database.
Evaluate the literals in the program from low level to the
high level.
Deductive Databases

- However, you cannot find any level mapping for the
following program:
Example:
path(X, Y)  edge(X, Y),
path(X,Y)  edge(X, Z), path(Z, Y),
acyclic_path(X, Y)  path(X,Y), path(Y, X).
We can many label mappings for this program. The following
are just two of them:

Deductive

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Deductive

Uploaded by

Copyright:

Available Formats

Deductive Databases

• What is a deductive database system?

• Some basic concepts from logic

- Example (a logic program)

Facts can be considered as the data stored as relations in a

• Basic inference mechanism for logic programs

- proof theoretic interpretation

1. superior(X, Y)  supervise(X, Y). (rule 1)

3. supervise(jennifer, ahmad). (ground axiom, given)

5. superior(jennifer, ahmad). (apply rule 1 on 3)

- model theoretic interpretation

domain = {james, franklin, john, ramesh, joyce, jennifer, alicia, ahmad}

Interpretation - model - minimal model

superior(franklin, john)  supervise(franklin, john) is true.

superior(X, Y)  supervise(X, Z), superior(Z, Y)

superior(james, ramesh)  supervise(james, franklin),

eliminating superior (james, ramesh) will make the following rule no

superior(james, ramesh)  supervise(james, franklin),

1. Check whether any of the existing facts directly matches the

All the facts of the form: superior(james, a) are the answers.

applying the first rule: superior(james, franklin), superior(james, jennifer)

applying the second rule: Y = {John, Joyce, Ramesh, alicia, ahmad}

Rule1: superior(james, Y)  Rule2: superior(james, Y) 

Rule1: superior(franklin, Y)  Rule1: superior(jennifer, Y) 

Y= john, ramesh, joyce Y= alicia, ahmad

• Datalog programs and their evaluation

• Datalog programs and their evaluation

- The following is a logic program, but not a

• Datalog programs and their evaluation

• Datalog programs and their evaluation

• Datalog programs and their evaluation

• Datalog programs and their evaluation

• Datalog programs and their evaluation

main_poductx_emp president over_40K_emp superior

department project female male

• Datalog programs and their evaluation

Evaluation of nonrecursive rules

• Datalog programs and their evaluation

$1 ($2 = “60000”(salary))

- evaluation involving only rule-based predicates

•Datalog programs and their evaluation

where the <condition> is a conjunctive condition made up of a

• Datalog programs and their evaluation

Evaluation of recursive rules

• Datalog programs and their evaluation

• Datalog programs and their evaluation

•Datalog programs and their evaluation

• Datalog programs and their evaluation

• Datalog programs and their evaluation

•Datalog programs and their evaluation

•Datalog programs and their evaluation

sg(X, Y) = X,Y(sg(X, W) sibling(W, Z) sg(Z, Y))

• Datalog programs and their evaluation

• Datalog programs and their evaluation

• Datalog programs and their evaluation

k-th iteration: k-th iteration:

•Datalog programs and their evaluation

•Datalog programs and their evaluation

•Datalog programs and their evaluation

•Datalog programs and their evaluation

•Datalog programs and their evaluation

•Datalog programs and their evaluation

•Datalog programs and their evaluation