1 / 59

Deductive Database Systems: Concepts and Inference Mechanisms

Learn about the basic concepts of deductive database systems and how they use an inference mechanism to derive new facts from existing ones. Explore key terms such as terms, literals, clauses, and logic programs. Discover the proof theoretic and model theoretic interpretations of rules and facts.

smithanthony
Download Presentation

Deductive Database Systems: Concepts and Inference Mechanisms

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Outline Chapter 25 – 3rd ed. (Chap. 24.4 – 4th, 5th ed.; 26.5, 6th ed.) • What is a deductive database system? • Some basic concepts • Basic inference mechanism for logic programs • Datalog programs and their evaluation Yangjun Chen ACS-3902

  2. What is a deductive database system? • A deductive database can be defined as an advanced database augmented with an inference system. Database Inference Deductive 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. Yangjun Chen ACS-3902

  3. 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 Yangjun Chen ACS-3902

  4. - 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) Yangjun Chen ACS-3902

  5. - 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. Yangjun Chen ACS-3902

  6. - 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: • B1  ...  Bm  A1  ...  An • or • B1, ..., Bm  A1 , ..., An consequent antecedent Yangjun Chen ACS-3902

  7. A A B B B  A A B 1 0 1 1 1 0 0 0 1 0 1 0 0 1 1 0 1 1 0 0 1 1 1 1 • - clause - Horn clause A Horn clause is a clause with the head containing only one positive atom. Bm  A1 , ..., An Yangjun Chen ACS-3902

  8. - 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. Yangjun Chen ACS-3902

  9. - Example (a logic program) Facts: supervise(franklin, john), supervise(franklin, ramesh), supervise(franklin, joyce) supervise(james, franklin), supervise(jennifer, alicia), supervise(jennifer, 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). james jennifer franklin ahmad john ramesh joyce alicia Yangjun Chen ACS-3902

  10. Facts can be considered as the data stored as relations in a relational database. Yangjun Chen ACS-3902

  11. 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. Yangjun Chen ACS-3902

  12. - 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) Yangjun Chen ACS-3902

  13. - 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. Yangjun Chen ACS-3902

  14. - Example: 1. superior(X, Y)  supervise(X, Y). (rule 1) 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), supervise(james, jennifer). For all other possible (X, Y) combinations supervise(X, Y) is false. domain = {james, franklin, john, ramesh, joyce, jennifer, alicia, ahmad} Yangjun Chen ACS-3902

  15. Interpretation - model - minimal model known facts: supervise(franklin, john), supervise(franklin, ramesh), supervise(franklin, joyce), supervise(james, franklin), supervise(jennifer, alicia), supervise(jennifer, ahmad), supervise(james, jennifer). For all other possible (X, Y) combinations supervise(X, Y) is false. 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. Yangjun Chen ACS-3902

  16. 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. Yangjun Chen ACS-3902

  17. 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) Yangjun Chen ACS-3902

  18. - 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. Yangjun Chen ACS-3902

  19. - 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. Yangjun Chen ACS-3902

  20. - Example: 1. superior(X, Y)  supervise(X, Y). (rule 1) 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), supervise(james, jennifer). For all other possible (X, Y) combinations supervise(X, Y) is false. 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} Yangjun Chen ACS-3902

  21. - 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. Yangjun Chen ACS-3902

  22. - Example query goal: ?-superior(james, Y) rules and facts are given as above. Query: ?-superior(james, Y) Rule2: superior(james, Y)  supervise(james, Z), superior(Z, Y) Rule1: superior(james, Y)  supervise(james, Y) Y=franklin, jennifer supervise(james, Z) Z=jennifer Z=frankiln superior(franklin, Y) superior(jennifer, Y) Yangjun Chen ACS-3902

  23. Rule1: superior(franklin, Y)  supervise(franklin, Y) Rule1: superior(jennifer, Y)  supervise(jennifer, Y) Y= alicia, ahmad Y= john, ramesh, joyce Yangjun Chen ACS-3902

  24. Datalogprograms and their evaluation • 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. Yangjun Chen ACS-3902

  25. Datalogprograms and their evaluation • 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).supervise(james, jennifer). • - The following is a logic program, but not a Datalog program: • p(X, Y)  q(f(Y), X) Yangjun Chen ACS-3902

  26. Datalogprograms and their evaluation • two important concepts: • - safety of programs • - predicate dependency graph Yangjun Chen ACS-3902

  27. Datalogprograms and their evaluation • - 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). Yangjun Chen ACS-3902

  28. Datalogprograms and their evaluation • - 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. Yangjun Chen ACS-3902

  29. Datalogprograms and their evaluation • 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. Yangjun Chen ACS-3902

  30. Datalogprograms and their evaluation • - 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)). Yangjun Chen ACS-3902

  31. workson department project employee female salary male supervise • Datalogprograms and their evaluation • - predicate dependency graphs supervisor under_40K_supervisor subordinate  main_poductx_emp president over_40K_emp superior  Yangjun Chen ACS-3902

  32. Datalogprograms and their evaluation • Evaluation of nonrecursive rules • - If the dependency graph for a rule set has no cycles, the rule set is nonrecursive. Yangjun Chen ACS-3902

  33. Datalogprograms and their evaluation • - 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 Yangjun Chen ACS-3902

  34. Datalogprograms 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). Yangjun Chen ACS-3902

  35. Datalogprograms and their evaluation • - 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), Yangjun Chen ACS-3902

  36. 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. Yangjun Chen ACS-3902

  37. 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.) Yangjun Chen ACS-3902

  38. Datalogprograms and their evaluation • 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 Yangjun Chen ACS-3902

  39. Datalogprograms and their evaluation • - 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) Yangjun Chen ACS-3902

  40. Datalogprograms and their evaluation • - some teminology for recursive queries • - 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)) Yangjun Chen ACS-3902

  41. Datalogprograms and their evaluation • - some teminology for recursive queries • - 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), then E i(g0) is the fixed point of the function E(...). It is also the least fixed point of E(...). E i(g0) = E (E( ... E(g0) ... )) i Yangjun Chen ACS-3902

  42. Datalogprograms and their evaluation • - some teminology for recursive queries • - 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 leastfixed point The least fixed point of the above equation is also called the transitive closure of p. Yangjun Chen ACS-3902

  43. Datalogprograms and their evaluation • - 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. Yangjun Chen ACS-3902

  44. Datalogprograms and their evaluation • - 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  Sithen {Con := false; Si := Ri;}} • until Con = true; Yangjun Chen ACS-3902

  45. Datalogprograms and their evaluation • - 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) sibling = E2(sibling) sg R1 R2 sibling R1 = E1(R1, R2) R2 = E2(R2) Yangjun Chen ACS-3902

  46. Datalogprograms and their evaluation • - 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 Yangjun Chen ACS-3902

  47. Datalogprograms and their evaluation • - 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)} • step 2: A2= {(bert, alice), (bert, george), (alice, derek), (alice, part), (derek, frank), (bert, derek), (bert, pat), (alice, frank)} • step 3: A3= {(bert, alice), (bert, george), (alice, derek), (alice, part), (derek, frank), (bert, derek), (bert, pat), (alice, frank), • (bert, frank)} • step 4: A4= A3 Yangjun Chen ACS-3902

  48. Datalogprograms and their evaluation • - naive strategy • Algorithm Gauss-Seidel naive strategy Jacobi: k-th iteration: R1(k) = E1(R1 (k-1), ..., Ri (k-1), ..., Rn (k-1)), … … Ri(k) = Ei(R1 (k-1), ..., Ri (k-1), ..., Rn (k-1)), … … Rn(k) = En(R1 (k-1), ..., Ri (k-1), ..., Rn (k-1)). Gauss-Seidel: k-th iteration: R1(k) = E1(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), ..., Ri (k), ..., Rn (k-1)). Yangjun Chen ACS-3902

  49. Datalogprograms and their evaluation • - evaluation of recursive queries • - semi-naive strategy • 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. Yangjun Chen ACS-3902

  50. Datalogprograms and their evaluation • - evaluation of recursive queries • - semi-naive strategy • 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; Yangjun Chen ACS-3902

More Related