Unification and Lifting
Download as PPTX, PDF•1 like•12,907 views
The document discusses inference rules for quantifiers in first-order logic. It describes the rules of universal instantiation and existential instantiation. Universal instantiation allows inferring sentences by substituting terms for variables, while existential instantiation replaces a variable with a new constant symbol. The document also introduces unification, which finds substitutions to make logical expressions identical. Generalized modus ponens is presented as a rule that lifts modus ponens to first-order logic by using unification to substitute variables.
![Subscribe
Unification
Lifted inference rules require finding substitutions that make different logical expressions look
identical. This process is called unification and is a key component of all first-order inference
algorithms.
The UNIFY algorithm takes two sentences and returns a unifier for them if one exists:
Substitution means replacing one variable with another term. It takes two literals as input and make
them identical using substitution. It returns fail if the expressions do not match with each other.
UNIFY(p, q) = θ where SUBST(θ, p) = SUBST(θ, q)
Example: P(x, y) (i)
P(a, f(z)) (ii)
Substitute x with a, and y with f(z) in the first expression and it will represented as a/x and f(z)/y.
With both the substitution the first expression will be identical to the second expression and the
substitution set will be [a/x, f(z)/y]](https://image.slidesharecdn.com/ai-21-210524162247/85/Unification-and-Lifting-7-320.jpg)
Unification and Lifting
- 2. Inference rules for quantifiers Unification and Lifting
- 3. Subscribe Inference rules for quantifiers The rule of Universal Instantiation (UI for short) says that we can infer any sentence obtained by substituting a ground term (a term without variables) for the variable. It can be applied multiple times to add new sentences. Suppose our knowledge base contains the axiom stating that All greedy kings are evil: ∀ x King(x) ∧ Greedy(x) ⇒ Evil(x) Then it seems quite permissible to infer any of the following sentences: King(John) ∧ Greedy(John) ⇒ Evil(John) King(Richard) ∧ Greedy(Richard) ⇒ Evil(Richard) King(Father (John)) ∧ Greedy(Father (John)) ⇒ Evil(Father (John)) . Let SUBST(θ,α) denote the result of applying the substitution θ to the sentence α. Then the rule is written ∀v α SUBST({v/g}, α) for any variable v and ground term g. For example, the three sentences are obtained with the substitutions {x/John}, {x/Richard}, and {x/Father (John)}
- 4. Subscribe Inference rules for quantifiers In the rule for Existential Instantiation, the variable is replaced by a single new constant symbol. It can be applied only once to replace the existential sentence. The formal statement is as follows: for any sentence α, variable v, and constant symbol k that does not appear elsewhere in the knowledge base, ∃v α SUBST({v/k}, α) . For example, from the sentence ∃ x Crown(x) ∧ OnHead(x, John) we can infer the sentence Crown(C1) ∧ OnHead(C1, John) as long as C1 does not appear elsewhere in the knowledge base. The existential sentence says there is some object satisfying a condition and applying the existential instantiation rule just gives a name to that object, this is called as Skolem constant.
- 5. Subscribe Generalized Modus Ponens Rule ∀ x King(x) ∧ Greedy(x) ⇒ Evil(x) King(John) Greedy(John) {x/John} solves the query Evil(x). In this case, the substitution θ = {x/John}. Suppose that instead of knowing Greedy(John), we know that everyone is greedy ∀ y Greedy(y) We have to find a substitution both for the variables in the implication sentence and for the variables in the sentences that are in the knowledge base. In this case, applying the substitution {x/John, y/John} to the implication premises King(x) and Greedy(x) and the knowledge-base sentences King(John) and Greedy(y) will make them identical. Thus, we can infer the conclusion of the implication. This inference process can be captured as a single inference rule that we call Generalized Modus Ponens.
- 6. Subscribe Generalized Modus Ponens Rule For atomic sentences pi, pi’ , and q, where there is a substitution θ such that SUBST(θ, pi’ ) = SUBST(θ, pi), for all i, p1’ , p2’ , ..., pn’ , (p1 ∧ p2 ∧ ... ∧ pn ⇒ q) SUBST(θ, q) There are n+ 1 premises to this rule: the n atomic sentences pi and the one implication. The conclusion is the result of applying the substitution θ to the consequent q. For our example: p1’ is King(John) p1 is King(x) p2’ is Greedy(y) p2 is Greedy(x) θ is {x/John, y/John} q is Evil(x) SUBST(θ, q) is Evil(John) . Generalized Modus Ponens is a lifted version of Modus Ponens—it raises Modus Ponens from ground (variable-free) propositional logic to first-order logic.
- 7. Subscribe Unification Lifted inference rules require finding substitutions that make different logical expressions look identical. This process is called unification and is a key component of all first-order inference algorithms. The UNIFY algorithm takes two sentences and returns a unifier for them if one exists: Substitution means replacing one variable with another term. It takes two literals as input and make them identical using substitution. It returns fail if the expressions do not match with each other. UNIFY(p, q) = θ where SUBST(θ, p) = SUBST(θ, q) Example: P(x, y) (i) P(a, f(z)) (ii) Substitute x with a, and y with f(z) in the first expression and it will represented as a/x and f(z)/y. With both the substitution the first expression will be identical to the second expression and the substitution set will be [a/x, f(z)/y]
- 8. Subscribe Unification Given : Knows(John, x) is a predicate. whom does John know? The UNIFY algorithm will search all the related sentences in the knowledge base , which could unify with Knows(John, x) UNIFY(Knows(John, x), Knows(John, Jane)) = {x/Jane} UNIFY(Knows(John, x), Knows(y, Bill)) = {x/Bill, y/John} UNIFY(Knows(John, x), Knows(x,Elizabeth)) = fail. The last unification fails because x cannot take on the values John and Elizabeth at the same time.
- 9. Subscribe Conditions for Unification 1. Predicate symbol must be same. Knows(John, Jane) Brother(John, Jane) fail 2. Number of arguments in both expressions must be identical. Hate(Marry) Hate(Marry, John) fail 3. Unification will fail if there are two similar variables present in the same expression. UNIFY(Knows(John, x), Knows(x, Elizabeth)) = fail.
- 10. Thanks For Watching Reference: Artificial Intelligence A Modern Approach Third Edition Peter Norvig and Stuart J. Russell Subscribe Like Share Next Topic: Forward and Backword Chaining
- 11. OMega TechEd About the Channel This channel helps you to prepare for BSc IT and BSc computer science subjects. In this channel we will learn Business Intelligence ,Artificial Intelligence, Digital Electronics, Internet OF Things Python programming , Data-Structure etc. Which is useful for upcoming university exams. Gmail: [email protected] Social Media Handles: omega.teched megha_with Subscribe