P1

What It Means:

● Universal Quantification (∀ v α): This means that a statement (let's call it α) is true
for all possible values of a variable v.
● Instantiation: Taking the general statement and applying it to a specific instance (or
value) for the variable v.

Rule of UI:

If you know something is true for all values of a variable (∀), then you can infer that it is true for
any specific value of that variable.

The Formal Rule:

1. Start with a universally quantified statement: ∀ v α (e.g., "For all x, something is true").
2. Replace the variable v with a specific "ground term" g (a concrete value, name, or
expression).
3. The result is a new statement that is entailed (logically follows) from the original
universal statement.

Notation:

● Subst({v/g}, α): Means "substitute v with g in α."

Example Walkthrough:

Original Statement:

∀ x (King(x) ∧ Greedy(x) ⇒ Evil(x))

● This says: "For all x, if x is a King and x is Greedy, then x is Evil."

Instantiating with Specific Terms:

Now we pick specific terms for x (like "John," "Richard," or a more complex expression like
"Father(John)"):
 1. Substitute x with "John": King(John) ∧ Greedy(John) ⇒ Evil(John)
○ This means: "If John is a King and John is Greedy, then John is Evil."
2. Substitute x with "Richard": King(Richard) ∧ Greedy(Richard) ⇒
Evil(Richard)
○ This means: "If Richard is a King and Richard is Greedy, then Richard is
Evil."
3. Substitute x with "Father(John)" (a more complex term): King(Father(John)) ∧
Greedy(Father(John)) ⇒ Evil(Father(John))
○ This means: "If John’s father is a King and John’s father is Greedy, then
John’s father is Evil."

Key Insights:

● Universal Instantiation allows us to derive specific instances from a general rule.

● The new specific statements (e.g., about John, Richard, or Father(John)) are logically
valid because they follow from the universal statement.

Why It Matters:

UI is a fundamental rule in logic and reasoning, enabling us to apply general principles (like laws
or rules) to specific situations or individuals.
P2

Explanation of Existential Instantiation (EI):

What it Means:

● Existential Quantification (∃ v α): This means that there exists at least one value for
the variable v that makes the statement α true.
● Instantiation: Taking the general statement (which claims something exists) and
replacing the variable with a specific, new constant symbol to represent the thing that
exists.

Rule of EI:

1. Start with an existentially quantified statement: ∃ v α (e.g., "There exists an x such

that something is true").
2. Replace the variable v with a new constant symbol k.
○ This constant symbol (k) must not already appear in the knowledge base to
avoid unintended conflicts or assumptions.
3. The result is a new statement that is logically equivalent to the original existential
statement.

Notation:

● Subst({v/k}, α): Means "substitute v with k in α."

● The constant symbol k is called a Skolem constant.

Example Walkthrough:

1. First Example:

∃ x (Crown(x) ∧ OnHead(x, John))

● This says: "There exists an x such that x is a Crown and x is on John's head."

Applying EI:

● Replace x with a new constant symbol, say C1 (a Skolem constant).

● The result is: Crown(C1) ∧ OnHead(C1, John)
 ○ This means: "There is some specific crown (we’ll call it C1) such that C1 is a
Crown and C1 is on John's head."

2. Second Example:

∃ x (d(x^y)/dy = x^y)

● This says: "There exists an x such that the derivative of x^y with respect to y
equals x^y."

Applying EI:

● Replace x with a new constant symbol, say e (a Skolem constant).

● The result is: d(e^y)/dy = e^y
○ This means: "There is some specific value (we’ll call it e) such that the
derivative of e^y with respect to y equals e^y."

Key Insights:

1. Why use a new constant symbol (k)?

○ The Skolem constant represents a specific, unknown entity that satisfies the
existential claim.
○ It ensures that the logic is sound and does not conflict with existing knowledge.
2. What is the result of EI?
○ It replaces the existential claim (∃) with a concrete statement about a specific
entity (k), enabling reasoning about this entity.

Why It Matters:

Existential Instantiation allows us to reason about existential claims by introducing concrete

entities that we can work with. It’s a key step in automated reasoning and proofs, especially in
logic and artificial intelligence systems.
P3

Let’s break this down and explain clearly:

Universal Instantiation (UI) and Equivalence:

● Key Feature of UI:

○ UI can be applied multiple times to derive specific instances from a universally
quantified statement.
○ Every time you apply UI, you generate a new specific sentence, but these new
sentences do not alter the logical meaning of the knowledge base (KB). The
original and the updated KB are logically equivalent.

Example of UI:

● Original KB: ∀ x (King(x) ⇒ Leader(x))

○ This means: "For all x, if x is a King, then x is a Leader."
● Apply UI for x = John: King(John) ⇒ Leader(John)
● Apply UI for x = Richard: King(Richard) ⇒ Leader(Richard)

Result:

● New KB: {∀ x (King(x) ⇒ Leader(x)), King(John) ⇒ Leader(John),

King(Richard) ⇒ Leader(Richard)}
○ The new KB contains more specific sentences, but it is still logically equivalent
to the original KB.

Existential Instantiation (EI) and Satisfiability:

● Key Feature of EI:

○ EI is applied once to replace an existentially quantified statement with a specific
new constant (a Skolem constant).
○ After this replacement, the new KB is not logically equivalent to the original KB
but is satisfiable if and only if the original KB was satisfiable.
○ This means the new KB preserves the "truthfulness" of the original KB, even
though it does not contain exactly the same information.

Why EI Doesn't Preserve Equivalence:

1. EI replaces the existential claim (∃) with a specific assumption (e.g., using a Skolem
constant).
 2. The original KB stated that "something exists" without specifying what it is.
3. The new KB assumes that this "something" is a specific thing, which is logically
stronger than the original claim.

Example of EI:

● Original KB: ∃ x (Crown(x) ∧ OnHead(x, John))

○ This means: "There exists an x such that x is a Crown and x is on John's head."
● Apply EI: Replace x with a Skolem constant C1.
○ New KB: {Crown(C1) ∧ OnHead(C1, John)}
■ This assumes a specific crown (C1) exists, rather than just saying "some
crown" exists.

Equivalence vs. Satisfiability:

● The new KB is not logically equivalent to the original because we added a specific
assumption.
● However, the new KB is satisfiable if and only if the original KB was satisfiable:
○ If there was some crown satisfying the original claim, then C1 satisfies the new
KB.

Inferential Equivalence:

Both UI and EI allow us to make inferences that are valid in the original KB:

● UI expands the KB with specific instances without altering its meaning.

● EI replaces existential claims, allowing reasoning about specific entities.

While the KBs differ (due to EI not preserving equivalence), the inferences we can draw remain
consistent, provided we reason correctly within the rules.
1. Reduction to Propositional Inference

● What it means:

○We take a knowledge base (KB) that contains first-order logic (FOL) sentences
(with quantifiers, variables, predicates, etc.) and convert it into a KB that uses
only propositional symbols (statements about specific entities without
variables).
○ This process involves instantiating universal statements (via UI) and treating the
resulting sentences as propositional facts.
● Why do this?

○ Propositional inference is simpler and can be handled by propositional logic

techniques like truth tables or resolution.

2. Starting KB (in FOL):

The original KB contains these sentences in first-order logic:

1. ∀ x (King(x) ∧ Greedy(x) ⇒ Evil(x))

○ This says: "For all x, if x is a King and x is Greedy, then x is Evil."
2. King(John)
○ This says: "John is a King."
3. Greedy(John)
○ This says: "John is Greedy."
4. Brother(Richard, John)
○ This says: "Richard is John’s brother."

3. Instantiating the Universal Sentence

Using Universal Instantiation (UI), we substitute x in ∀ x (King(x) ∧ Greedy(x) ⇒

Evil(x)) with specific constants (like John and Richard):

Step 1: Substitute x = John

● From ∀ x (King(x) ∧ Greedy(x) ⇒ Evil(x)), we get: King(John) ∧

Greedy(John) ⇒ Evil(John)

Step 2: Substitute x = Richard

 ● From ∀ x (King(x) ∧ Greedy(x) ⇒ Evil(x)), we get: King(Richard) ∧
Greedy(Richard) ⇒ Evil(Richard)

4. Updated KB After Instantiation

Now the KB contains only grounded (variable-free) sentences:

1. King(John)
2. Greedy(John)
3. Brother(Richard, John)
4. King(John) ∧ Greedy(John) ⇒ Evil(John)
5. King(Richard) ∧ Greedy(Richard) ⇒ Evil(Richard)

5. Propositionalization

● In propositional logic, we replace each grounded predicate (like King(John)) with a

propositional symbol.
● Each predicate becomes a unique symbol:
○ King(John) → P1
○ Greedy(John) → P2
○ Evil(John) → P3
○ King(Richard) → P4
○ Greedy(Richard) → P5
○ Brother(Richard, John) → P6

The KB now looks like this in propositional terms:

1. P1 (John is a King)
2. P2 (John is Greedy)
3. P6 (Richard is John’s brother)
4. P1 ∧ P2 ⇒ P3 (If John is a King and Greedy, then he is Evil)
5. P4 ∧ P5 ⇒ P7 (If Richard is a King and Greedy, then he is Evil)

6. Why Propositionalization Helps

● The original FOL KB contained quantifiers (∀), variables (x), and predicates (King(x)).
 ● After propositionalization, the KB uses only propositional symbols (P1, P2, etc.),
simplifying inference to propositional logic techniques.
● Caveat: This approach may cause an explosion of propositions if the domain (set of
constants) is large.

7. Final Result:

● The new KB contains only propositional sentences, which can be evaluated using truth
tables or resolution.
● All reasoning becomes purely propositional, allowing for simpler computational methods.
1. Claim: A Ground Sentence is Entailed by the New KB if and only if it is
Entailed by the Original KB

● What is a ground sentence?

○ A sentence with no variables (only constants and function symbols).

○ Example: King(John) ∧ Greedy(John) ⇒ Evil(John).
● What this means:

○ If you propositionalize an FOL KB (convert it to propositional logic), you don’t lose

any inferential power. Any ground sentence entailed by the original FOL KB will
still be entailed by the propositionalized KB, and vice versa.
● Why?

○ Propositionalization is essentially "unrolling" the FOL KB into specific cases,

which preserves logical relationships.

2. Claim: Every FOL KB Can Be Propositionalized to Preserve Entailment

● What this means:

○ For any FOL KB, you can always convert it into an equivalent propositional KB
that preserves entailment. In other words:
■ If the original FOL KB entails a query α, the propositionalized KB will also
entail α.
● Why Propositionalization Helps:

○ Propositional logic is simpler than FOL and can use efficient algorithms like
resolution to answer queries.

3. The Challenge of Function Symbols

● What are function symbols?

○ These are expressions that generate new terms.

○ Example: Father(John) creates a new term, and Father(Father(John))
creates yet another.
● The Problem:

○ With function symbols, there are infinitely many ground terms.

○ Example: You can keep nesting terms like Father(Father(Father(John))).
○ This leads to an infinitely large propositional KB, making direct
propositionalization infeasible.

4. Herbrand's Theorem (1930):

● What it says:

○ If a sentence α is entailed by an FOL KB, it is entailed by a finite subset of the

propositionalized KB.
● Why it helps:

○ Instead of trying to propositionalize the entire KB (which might be infinite), you

can focus on a finite subset of ground terms and still decide entailment.
● Herbrand's Idea:

○ You systematically generate ground terms of increasing depth (complexity).

○ For depth 0: Use only constants (e.g., John).
○ For depth 1: Include terms like Father(John).
○ For depth 2: Include terms like Father(Father(John)).
○ Repeat this process until you find a subset that resolves the query α.

5. Algorithm to Check Entailment:

1. For n = 0 to ∞:
○ Generate a propositional KB by instantiating terms with depth n.
○ Check if α (the query) is entailed by this KB.
2. If α is entailed: Stop and return the result.
3. If α is not entailed: Keep increasing n.
● The Problem:
○ If α is not entailed by the KB, this process will never terminate (it "loops"
forever).

6. Turing and Church (1936): Semidecidability of FOL Entailment

● What "semidecidable" means:

○ If the FOL KB does entail a query α, the process will eventually find a proof.
○ However, if the FOL KB does not entail α, the process may never terminate.
● Why this happens:

○ FOL entailment is inherently undecidable (there is no general algorithm to decide

entailment in all cases).
○ You can only semi-decide:
■ Success: If α is entailed, you find the proof eventually.
■ Failure: If α is not entailed, the process loops infinitely without concluding.

Key Takeaways:

1. Propositionalization preserves entailment: Any ground sentence entailed by the

original FOL KB will also be entailed by the propositionalized KB.
2. Function symbols create infinite terms: This makes direct propositionalization
impractical for some KBs.
3. Herbrand's Theorem: Only a finite subset of the propositionalized KB is needed to
decide entailment for a given query.
4. FOL entailment is semidecidable:
○ If the query is entailed, you’ll eventually find a proof.
○ If not, the process may loop forever without providing an answer.
 Why Propositionalization Generates Many Irrelevant Sentences

Propositionalization is a brute-force method of converting First-Order Logic (FOL) into

Propositional Logic by grounding (instantiating) every possible combination of constants,
predicates, and function symbols. While this approach works, it often creates many irrelevant
sentences that don't help answer the query. Let's analyze why this happens.

Example Breakdown:

We start with the following FOL KB:

1. ∀ x (King(x) ∧ Greedy(x) ⇒ Evil(x))

○ "For all x, if x is a King and Greedy, then x is Evil."

2. King(John)

○ "John is a King."
3. ∀ y Greedy(y)

○ "Everyone is Greedy."
4. Brother(Richard, John)

○ "Richard is John's brother."

Intuitive Conclusion:

From the KB, it's obvious that:

● Evil(John) is true because:

○ King(John) is true.
○ Greedy(John) is true (since everyone is Greedy).

The other facts, like Greedy(Richard) or Brother(Richard, John), are irrelevant to the
query Evil(John).

What Happens During Propositionalization:

 Step 1: Instantiate Universal Sentences

We ground the universal statements by substituting all possible constants into the predicates.

1. From ∀ x (King(x) ∧ Greedy(x) ⇒ Evil(x)):

○ Ground terms: x = John, x = Richard, etc.

○ Propositionalized:
■ King(John) ∧ Greedy(John) ⇒ Evil(John)
■ King(Richard) ∧ Greedy(Richard) ⇒ Evil(Richard)
■ More terms are generated for other constants.
2. From ∀ y Greedy(y):

○ Ground terms: y = John, y = Richard, etc.

○ Propositionalized:
■ Greedy(John)
■ Greedy(Richard)
■ More terms for other constants.

Step 2: Explosion of Irrelevant Sentences

● Propositionalization generates sentences like Greedy(Richard) or Evil(Richard)

even though the query Evil(John) has no dependency on Richard.
● For each k-ary predicate (e.g., King(x), Greedy(x)), the number of ground
instances grows as: p⋅nkp \cdot n^k where:
○ p = number of predicates,
○ n = number of constants,
○ k = arity of the predicate.
● If function symbols are included, the explosion becomes even worse because of infinite
terms like Father(Father(John)).

Why This is Inefficient

● Irrelevant facts: For a specific query (e.g., Evil(John)), many generated sentences
(like Greedy(Richard)) don't contribute to answering it.
● Computational cost: The grounding process wastes time and resources by instantiating
predicates that don't matter to the query.
 How to Address This Problem

1. Focus on Relevant Facts

● Use reasoning techniques like forward chaining or backward chaining to limit

propositionalization to sentences directly relevant to the query.
● Example:
○ If the query is Evil(John), only instantiate sentences involving John.

2. Unification

● Instead of grounding all possible terms, use unification to substitute terms dynamically
during inference. This avoids generating irrelevant facts.

3. Smart Instantiation

● Limit instantiation depth for function symbols to avoid infinite terms.

● Use heuristic methods to prioritize instantiating terms that are more likely to help answer
the query.

4. Resolution in FOL

● Use first-order resolution directly without propositionalizing the entire KB, keeping the
representation compact and focused.

Summary

● Why propositionalization generates irrelevant facts:

○ It brute-forces every possible instantiation of predicates, constants, and function
symbols without considering the query.
○ This leads to an explosion of sentences, most of which are irrelevant.
● The problem worsens with function symbols: Infinite terms make exhaustive
grounding impractical.
● Solutions:
○ Focus on relevant facts using reasoning techniques like unification or chaining.
○ Limit depth and scope of propositionalization.
1. Unification Overview

● What it is:
○ Unification is the process of finding a substitution 𝜃 (a set of variable
assignments) that makes two logical expressions (predicates) identical.
● What substitution 𝜃 does:
○ A substitution replaces variables in a predicate with constants, other variables, or
functions.
○ Example: If 𝜃={𝑥/𝐽𝑜ℎ𝑛,𝑦/𝐽𝑎𝑛𝑒}, then:
■ 𝐾𝑛𝑜𝑤𝑠(𝑥,𝑦) becomes 𝐾𝑛𝑜𝑤𝑠(𝐽𝑜ℎ𝑛,𝐽𝑎𝑛𝑒).
● Formal definition of unification:
○ Two expressions 𝛼 and 𝛽 unify if there exists a substitution 𝜃 such
that:𝑆𝑈𝐵𝑆𝑇(𝜃,𝛼)=𝑆𝑈𝐵𝑆𝑇(𝜃,𝛽)
○ 𝜃 is called the unifier.

2. Example 1: Matching Predicates

The task is to unify two predicates, 𝑝 and 𝑞, by finding a substitution 𝜃. Let’s analyze the
examples provided:

Example 1: 𝑝=𝐾𝑛𝑜𝑤𝑠(𝐽𝑜ℎ𝑛,𝑥), 𝑞=𝐾𝑛𝑜𝑤𝑠(𝐽𝑜ℎ𝑛,𝐽𝑎𝑛𝑒)

● What needs to match:

○ The predicate name (Knows) and the first argument (John) already match.
○ The second argument, x in 𝑝 and Jane in 𝑞, does not match.
● Substitution 𝜃:
○ 𝜃={𝑥/𝐽𝑎𝑛𝑒}
● Result after substitution:
○ 𝑆𝑈𝐵𝑆𝑇(𝜃,𝐾𝑛𝑜𝑤𝑠(𝐽𝑜ℎ𝑛,𝑥))=𝐾𝑛𝑜𝑤𝑠(𝐽𝑜ℎ𝑛,𝐽𝑎𝑛𝑒)

Example 2: 𝑝=𝐾𝑛𝑜𝑤𝑠(𝐽𝑜ℎ𝑛,𝑥), 𝑞=𝐾𝑛𝑜𝑤𝑠(𝑦,𝑂𝐽)

● What needs to match:

○ The predicate name (Knows) matches.
○ John (first argument of 𝑝) and y (first argument of 𝑞) need to match.
○ 𝑥 (second argument of 𝑝) and 𝑂𝐽 (second argument of 𝑞) need to match.
● Substitution 𝜃:
○ 𝜃={𝑦/𝐽𝑜ℎ𝑛,𝑥/𝑂𝐽}
● Result after substitution:
○ 𝑆𝑈𝐵𝑆𝑇(𝜃,𝐾𝑛𝑜𝑤𝑠(𝐽𝑜ℎ𝑛,𝑥))=𝐾𝑛𝑜𝑤𝑠(𝐽𝑜ℎ𝑛,𝑂𝐽)
Example 3: 𝑝=𝐾𝑛𝑜𝑤𝑠(𝐽𝑜ℎ𝑛,𝑥), 𝑞=𝐾𝑛𝑜𝑤𝑠(𝑦,𝑀𝑜𝑡ℎ𝑒𝑟(𝑦))

● What needs to match:

○ The predicate name (Knows) matches.
○ John (first argument of 𝑝) and y (first argument of 𝑞) need to match.
○ 𝑥 (second argument of 𝑝) and 𝑀𝑜𝑡ℎ𝑒𝑟(𝑦) (second argument of 𝑞) need to match.
● Substitution 𝜃:
○ 𝜃={𝑦/𝐽𝑜ℎ𝑛,𝑥/𝑀𝑜𝑡ℎ𝑒𝑟(𝐽𝑜ℎ𝑛)}
● Result after substitution:
○ 𝑆𝑈𝐵𝑆𝑇(𝜃,𝐾𝑛𝑜𝑤𝑠(𝐽𝑜ℎ𝑛,𝑥))=𝐾𝑛𝑜𝑤𝑠(𝐽𝑜ℎ𝑛,𝑀𝑜𝑡ℎ𝑒𝑟(𝐽𝑜ℎ𝑛))

Example 4: 𝑝=𝐾𝑛𝑜𝑤𝑠(𝐽𝑜ℎ𝑛,𝑥), 𝑞=𝐾𝑛𝑜𝑤𝑠(𝑥,𝑂𝐽)

● What needs to match:

○ The predicate name (Knows) matches.
○ John (first argument of 𝑝) and x (first argument of 𝑞) need to match.
○ 𝑥 (second argument of 𝑝) and 𝑂𝐽 (second argument of 𝑞) need to match.
● Substitution 𝜃:
○ 𝜃={𝑥/𝐽𝑜ℎ𝑛}
● Result after substitution:
○ 𝑆𝑈𝐵𝑆𝑇(𝜃,𝐾𝑛𝑜𝑤𝑠(𝐽𝑜ℎ𝑛,𝑥))=𝐾𝑛𝑜𝑤𝑠(𝐽𝑜ℎ𝑛,𝑂𝐽)
○ 𝑆𝑈𝐵𝑆𝑇(𝜃,𝐾𝑛𝑜𝑤𝑠(𝑥,𝑂𝐽))=𝐾𝑛𝑜𝑤𝑠(𝐽𝑜ℎ𝑛,𝑂𝐽)

3. Key Points About Unification

● Successful unification: Happens when a substitution 𝜃 exists that makes two

predicates identical after applying it.
● Failures in unification:
○ Mismatch in predicate names: E.g., Loves(John, x) cannot unify with
Knows(John, Jane).
○ Conflict in constants: E.g., Knows(John, x) cannot unify with Knows(Jane,
y) because John and Jane are distinct constants.

4. Applications of Unification

● Inference in FOL: Unification is used in algorithms like resolution to determine logical

entailment.
 ● Efficiency: By finding the minimal substitution 𝜃, we can focus on relevant terms and
avoid generating irrelevant facts.

Unification is a foundational concept in automated reasoning and forms the basis for logical
inference systems like Prolog.
Explanation of Generalized Modus Ponens (GMP)

Generalized Modus Ponens (GMP) is an extension of the classical Modus Ponens rule in
propositional logic. It applies in the context of First-Order Logic (FOL), where predicates
contain variables. GMP allows inference by matching facts with universally quantified rules
through substitutions.

Breakdown of the Given Text

1. What GMP Does

● Input:
○ A set of facts 𝑝1′,𝑝2′,…,𝑝𝑛′.
○ A universally quantified rule: 𝑝1∧𝑝2∧…∧𝑝𝑛⇒𝑞.
● Process:
○ Find a substitution 𝜃 that makes the rule’s antecedent 𝑝1,…,𝑝𝑛 match the facts
𝑝1′,…,𝑝𝑛′.
● Output:
○ The conclusion 𝑞, instantiated with 𝜃, written as 𝑞𝜃.

2. Matching in the Example

● Rule: 𝑝1∧𝑝2⇒𝑞
○ 𝑝1=𝐾𝑖𝑛𝑔(𝑥)
○ 𝑝2=𝐺𝑟𝑒𝑒𝑑𝑦(𝑥)
○ 𝑞=𝐸𝑣𝑖𝑙(𝑥)
● Facts:
○ 𝑝1′=𝐾𝑖𝑛𝑔(𝐽𝑜ℎ𝑛)
○ 𝑝2′=𝐺𝑟𝑒𝑒𝑑𝑦(𝐽𝑜ℎ𝑛)
● Substitution 𝜃={𝑥/𝐽𝑜ℎ𝑛,𝑦/𝐽𝑜ℎ𝑛} makes:
○ 𝑝1′𝜃=𝑝1𝜃=𝐾𝑖𝑛𝑔(𝐽𝑜ℎ𝑛),
○ 𝑝2′𝜃=𝑝2𝜃=𝐺𝑟𝑒𝑒𝑑𝑦(𝐽𝑜ℎ𝑛).
● Conclusion:
○ 𝑞𝜃=𝐸𝑣𝑖𝑙(𝐽𝑜ℎ𝑛).

Thus, 𝐸𝑣𝑖𝑙(𝐽𝑜ℎ𝑛) is inferred.

Key Points in the Text

Soundness of GMP
GMP is sound, meaning the conclusion 𝑞𝜃 is logically entailed by the given facts and rule. The
proof ensures this through three steps:

Step 1: Validity of Substituted Rule

● The original rule 𝑝1∧…∧𝑝𝑛⇒𝑞 is instantiated with the substitution 𝜃,

producing:(𝑝1∧…∧𝑝𝑛⇒𝑞)⊨(𝑝1𝜃∧…∧𝑝𝑛𝜃⇒𝑞𝜃).
● This step uses Universal Instantiation (UI), which states that if a universally quantified
sentence is true, then any ground instance (specific case) is also true.

Step 2: Matching Facts

● The facts 𝑝1′,…,𝑝𝑛′ are true, so their conjunction 𝑝1′∧…∧𝑝𝑛′ is also true.
● Since 𝑝𝑖′𝜃=𝑝𝑖𝜃 for all 𝑖, we conclude:𝑝1′𝜃∧…∧𝑝𝑛′𝜃=𝑝1𝜃∧…∧𝑝𝑛𝜃.

Step 3: Applying Modus Ponens

● From Step 1 (substituted rule) and Step 2 (matching facts), we can apply the classical
Modus Ponens:(𝑝1𝜃∧…∧𝑝𝑛𝜃⇒𝑞𝜃),(𝑝1𝜃∧…∧𝑝𝑛𝜃)⊨𝑞𝜃.
● This concludes that 𝑞𝜃 is true, which in this example is 𝐸𝑣𝑖𝑙(𝐽𝑜ℎ𝑛).

Key Definitions in Context

1. Definite Clauses:
○ A clause with exactly one positive literal (e.g., 𝑝1∧𝑝2⇒𝑞).
○ All variables are assumed to be universally quantified.
2. Substitution 𝜃:
○ A mapping of variables to constants, variables, or function terms that makes
predicates match.
3. Unification:
○ The process of finding 𝜃 such that 𝑝𝑖′𝜃=𝑝𝑖𝜃.
4. Universal Instantiation (UI):
○ Replacing universally quantified variables with specific constants or terms.

Summary of How GMP Works

 1. Start with a rule 𝑝1∧…∧𝑝𝑛⇒𝑞 and facts 𝑝1′,…,𝑝𝑛′.
2. Use unification to find 𝜃, making 𝑝𝑖′ and 𝑝𝑖 identical for all 𝑖.
3. Substitute 𝜃 into the conclusion 𝑞, yielding 𝑞𝜃.
4. Infer 𝑞𝜃 using sound logical reasoning (Modus Ponens).

Example Recap

● Rule: 𝐾𝑖𝑛𝑔(𝑥)∧𝐺𝑟𝑒𝑒𝑑𝑦(𝑥)⇒𝐸𝑣𝑖𝑙(𝑥).
● Facts: 𝐾𝑖𝑛𝑔(𝐽𝑜ℎ𝑛),𝐺𝑟𝑒𝑒𝑑𝑦(𝐽𝑜ℎ𝑛).
● Substitution: 𝜃={𝑥/𝐽𝑜ℎ𝑛}.
● Conclusion: 𝐸𝑣𝑖𝑙(𝐽𝑜ℎ𝑛).