Why Logic?

• Remember: Everything in AI is either representation or search

• Logical formulas are often a very convenient representation

• Why convenient?

  • Can be generated automatically
  • Can be processed automatically
  • Are very expressive

• Logic is used extensively in AI!

Propositional Logic

• $a \wedge b$: a and b

• $a \vee b$: a or b (or both!)

• $\neg a$: not a

• $a \rightarrow b$: a implies b, which means: if a is true, b also has to be true (but if a is false, b can be true or false). Logically equivalent to $\neg a \vee b$

• When you see iff (or in Spanish "sii", "ssi" or "syss") in text it is not a typo, it means "if and only if", a bidirectional implication ("a iff b" means that if a is true b is true, but if a is false, b is also false)

Propositional Logic

• How do we tell if a formula is true?

• We need to know if a and b (and all other constants) are "true"

• In other words, if we have some "interpretation" W of a and b, we can determine truth values

• $W \models a \wedge b$ iff a and b are both true in W, i.e. $W \models a$ and $W \models b$

• So what is W?

Interpretations

$$W = \{a, b, c\}$$

$$W \models a \wedge b \\ W \models a \vee d \\ W \not\models a \wedge d\\ W \models d \rightarrow a\\ \ldots$$

Predicate Logic

• Representing any non-trivial state in propositional logic is tedious (imagine chess: there has to be one variable for each possible location of each piece)

• Predicate Logic, on the other hand, represents the world as objects and relations between them

• Objects: constants

• Relations: Sets of n-tuples of objects, called predicates (n is the arity of the predicate)

• (Functors: Assignments of n-tuples of objects to objects)

• We also have quantifiers $\forall, \exists$

Predicate Logic: Example

$$\mathit{human}(\mathit{socrates})\\ \forall h: \mathit{human}(h) \rightarrow \mathit{mortal}(h)\\ \mathit{friends}(\mathit{socrates}, \mathit{plato})$$

Predicate Logic: Example

$$\mathit{human}(\mathit{socrates})\\ \forall h: \mathit{human}(h) \rightarrow \mathit{mortal}(h)\\ \mathit{friends}(\mathit{socrates}, \mathit{plato})$$ $\mathit{human}(h)$ is an unary relation, i.e. a set of 1-tuples/single elements. It is often more convenient to write:

$$\forall h \in \mathit{human}: \mathit{mortal}(h)$$

Predicate Logic: Example

$$\mathit{human}(\mathit{socrates})\\ \forall h: \mathit{human}(h) \rightarrow \mathit{mortal}(h)\\ \mathit{friends}(\mathit{socrates}, \mathit{plato})$$ $\mathit{human}(h)$ is an unary relation, i.e. a set of 1-tuples/single elements. It is often more convenient to write:

$$\forall h \in \mathit{human}: \mathit{mortal}(h)$$ Using set-operators, we could also write $(\mathit{socrates}, \mathit{plato}) \in \mathit{friends}$

In fact, as we will see, that's how our interpretations work.

Predicate Logic: Syntax

• A predicate name with parameters is called an Atom or atomic formula, e.g. $\mathit{human}(h)$

• A literal is an atom of the negation of an atom, e.g. $\neg \mathit{human}(h)$

• The h can either be a constant or a variable

• If h is part of our domain, it is a constant

• If h does not refer to any concrete object, it is a variable. A variable can be bound by a quantifier, or it can be unbound/free

• A formula with no free variables is called ground

Predicate Logic: Syntax

• Given two predicate logic formulas $\phi$ and $\psi$, we can use the usual logical connectives $\wedge, \vee, \rightarrow, \neg$ to construct more complex formulas

• Conceptually, this will result in a (syntax) tree, where each interior node is an operator, and the leaves are atoms

• If we have a formula $\phi$ that contains a free variable x, we can substitute that variable with a value t, written $\phi[t/x]$

Predicate Logic: Semantics

• Given a (ground) formula $\phi$ and an interpretation/world $W$, we want to know if the formula holds in that world, i.e. if the world is a model for the formula

• We write this as $W \models \phi$ ("W models phi")

• How do we determine that?

  • If $\phi$ is an atom, it is true iff $\phi \in W$
  • If $\phi$ is a more complex formula, use the syntax tree to determine the truth value

Predicate Logic: Semantics

$$W \models \neg \phi \:\:\text{iff}\:\:W \not\models \phi\\ W \models \phi \wedge \psi\:\:\text{iff}\:\:W \models \phi\:\:\text{and}\:\:W \models \psi\\ W \models \phi \vee \psi\:\:\text{iff}\:\:W \models \phi\:\:\text{or}\:\:W \models \psi\\ W \models \phi \rightarrow \psi\:\:\text{iff}\:\:W \not\models \phi\:\:\text{or}\:\:W \models \psi\\ W \models \forall x \in X: \phi\:\:\text{iff}\:\:W \models \phi[t/x]\:\:\text{for all}\:t \in X\\ W \models \exists x \in X: \phi\:\:\text{iff}\:\:W \models \phi[t/x]\:\:\text{for any}\:t \in X$$

Predicate Logic: Interpretations

W: $$\mathit{human} = \{\mathit{socrates}, \mathit{plato}, \mathit{aristotle}\}\\ \mathit{mortal} = \{\mathit{socrates}, \mathit{plato}, \mathit{aristotle}, \mathit{DonaldDuck}\}\\ \mathit{friends} = \{(\mathit{socrates}, \mathit{plato}), (\mathit{socrates}, \mathit{DonaldDuck})\}\\ $$

$$W \models \mathit{human}(\mathit{socrates}) \\ W \models \forall h: \mathit{human}(h) \rightarrow \mathit{mortal}(h) \\ W \models \mathit{friends}(\mathit{socrates}, \mathit{plato})\\ W \not\models \mathit{friends}(\mathit{socrates}, \mathit{socrates})\\ \ldots$$

Predicate Logic: Interpretations

$$W = \{\mathit{human}(\mathit{socrates}), \mathit{human}(\mathit{plato}), \mathit{human}(\mathit{aristotle}), \\ \mathit{mortal}(\mathit{socrates}), \mathit{mortal}(\mathit{plato}), \mathit{mortal}(\mathit{aristotle}), \mathit{mortal}(\mathit{DonaldDuck}),\\ \mathit{friends}(\mathit{socrates}, \mathit{plato}), \mathit{friends}(\mathit{socrates}, \mathit{DonaldDuck})\}\\ $$

$$W \models \mathit{human}(\mathit{socrates}) \\ W \models \forall h: \mathit{human}(h) \rightarrow \mathit{mortal}(h) \\ W \models \mathit{friends}(\mathit{socrates}, \mathit{plato})\\ W \not\models \mathit{friends}(\mathit{socrates}, \mathit{socrates})\\ \ldots$$

Data Structures

• If we actually want to use logic for something, we need an implementation

• We will start with how to store formulas and interpretations in data structures

• This will provide us with a way to query the truth-values of logical formulas under an interpretation

• Later we will see how we can manipulate these interpretations

Data Structure: And

class And(LogicalFormula):
    def __init__(self, children):
        self.children = children
    def isModeledBy(self, world):
        result = True 
        for c in self.children:
            result = result and c.isModeledBy(world)
        return result

Note: This and can have more than two children, which is a useful optimization!

Data Structures

• Now we can represent logical interpretations and formulas

• We can use this to determine which formulas hold under our interpretation

• An agent could, for example, use this to collect some true data and then reason about which rules hold (e.g. collect information about all animals and items in a zoo, and then determine if every animal has something to eat)

• The other direction is even more interesting, though: Collect some information and have the rules, and "generate" more information

Inference

• Just having a static interpretation of the world is not very interesting

• One form of intelligence could be to generate/derive "new" knowledge

• Or answer questions

• This process is called inference

Inference

• Facts: What we know about the world, which includes literals and formulas

• Rules: Logical instructions that tell us how we can generate more facts, using properties of logic

• You can also imagine this as a logical proof: We know some things about the world, and we prove that some other things logically follow

Inference Algorithms

• In practice, we may have "many" possible facts

• Imagine a logical reasoning system for natural numbers: We can say a number is prime if it has some properties (number of proper divisors is equal to two), but we don't want the agent to generate all prime numbers

• Instead we can answer queries: Does a particular formula hold, e.g. "Is 9 a prime number"?

• There are several different algorithms to answer such queries

Resolution

• Resolution is one such algorithm to perform inference

• The idea is to take disjunctions ("or"s) of logical literals as rules

• If we know that one of this literals is false, we can infer that at least one of the others must be true

• Also remember that an implication is also an or!

$$a \rightarrow b \Leftrightarrow \neg a \vee b\\ {\neg a \vee b, a} \models b$$

How to do queries: We negate the query and try to "resolve" it with what we know

$${\neg a \vee b, a, \neg b} \models \bot$$

Actions?

• We often want to represent a world that is changing, rather than just static facts

• Simple solution: Let's use constants representing (discrete) times, and increase the arity of each predicate by one to account for time

• For example, $\mathit{human}(\mathit{socrates})$ becomes $\mathit{human}(\mathit{socrates}, 0)$, or $\forall t \in T: \mathit{human}(\mathit{socrates}, t)$

• An action is something that changes some truth values over time, often represented as an implication, like $\mathit{alive}(\mathit{socrates}, 400 \text{BCE}) \rightarrow \neg \mathit{alive}(\mathit{socrates}, 399 \text{BCE})$

• This can be generalized with quantifiers and special predicates that indicate when actions occur, if needed

The Yale Shooting Problem

• Consider Fred, a turkey, and a gun

• At time 0, Fred is alive and the gun is unloaded

• We load the gun, so that at time 1 the gun is loaded

• Then we wait

• At time 2 we shoot, such that at time 3 Fred is dead

The Yale Shooting Problem

$$\mathit{alive}(\mathit{Fred}, 0)\\ \neg \mathit{loaded}(\mathit{Gun}, 0)\\ \neg \mathit{loaded}(\mathit{Gun}, 0) \rightarrow \mathit{loaded}(\mathit{Gun}, 1)\\ \mathit{loaded}(\mathit{Gun}, 2) \rightarrow \neg \mathit{alive}(\mathit{Fred}, 3)$$

The Yale Shooting Problem

$$\mathit{alive}(\mathit{Fred}, 0)\\ \neg \mathit{loaded}(\mathit{Gun}, 0)\\ \neg \mathit{loaded}(\mathit{Gun}, 0) \rightarrow \mathit{loaded}(\mathit{Gun}, 1)\\ \mathit{loaded}(\mathit{Gun}, 2) \rightarrow \neg \mathit{alive}(\mathit{Fred}, 3)$$

What about $\mathit{alive}(\mathit{Fred}, 1)$?

What about $\mathit{loaded}(\mathit{Gun}, 2)$?

Idea: Let's say "the least" number of things change each time step!

The Yale Shooting Problem

$$\mathit{alive}(\mathit{Fred}, 0)\\ \neg \mathit{loaded}(\mathit{Gun}, 0)\\ \neg \mathit{loaded}(\mathit{Gun}, 0) \rightarrow \mathit{loaded}(\mathit{Gun}, 1)\\ \mathit{loaded}(\mathit{Gun}, 2) \rightarrow \neg \mathit{alive}(\mathit{Fred}, 3)$$

What about $\mathit{alive}(\mathit{Fred}, 1)$?

What about $\mathit{loaded}(\mathit{Gun}, 2)$?

Idea: Let's say "the least" number of things change each time step!

The turkey could still die at time step 1 and stay dead ...

The Frame Problem

• The Yale Shooting Problem is an illustration of the Frame Problem: Everything that is not changed by an action (the "frame") should stay the same

• But how would we even write this in logical formulas?

• There are several solutions!

• One approach: Frame axioms. For each action state what the action leaves unchanged. This may require a lot of extra formulas.

• Another approach: Distinguish states and actions, and represent changes as a transition system

Transition System Approach

• We start with an initial state $s_0 = \{\mathit{alive}(\mathit{Fred}), \neg \mathit{loaded}(\mathit{Gun}) \}$ (or, using the closed-world assumption simply $s_0 = \{\mathit{alive}(\mathit{Fred})\}$), which we can use for logical queries such as $s_0 \models \mathit{alive}(\mathit{Fred})$

• We have an action load(Gun) which turns a state into another state:

  • If the Gun is not loaded, it becomes loaded
  • If the Gun is already loaded, nothing happens

• $s_1 = \{\mathit{alive}(\mathit{Fred}), \mathit{loaded}(\mathit{Gun}) \}$

• Now we can query $s_1 \models \mathit{alive}(\mathit{Fred})$

Transition System Approach

• This forms the basis for the planning problem, which we will discuss for the rest of the semester

• We can express many interesting problems this way, such as how to distribute packages using trucks and airplanes, determine a robot's actions to perform a task, play games, etc.

• However, it also has drawbacks: If our states only represent individual time steps, we can't (easily) query things like "how long was Fred alive"

• As another part of task 1 you will implement a way to apply actions to worlds/states

What is an action?

• We consider our actions to consist of two parts: a precondition and an effect

• The precondition tells us when we can use an action (e.g. we can only shoot if we even have the gun)

• The effect tells us what happens (if the gun is loaded, we kill the turkey, otherwise nothing happens)

• We can determine if a precondition holds in a world with our models function

• We also need to be able to apply an effect, which is where apply comes in

Effect Application

• Since an effect is just a formula, we could add a method to our base class:

def apply(self, world):
    return world

• Depending on the formula, we can then override this method and apply the changes of the subformulas

• This may be tricky to get right (particularly negated literals), I'll show you another way later

• For And you can do something like:

def apply(self, world):
    result = world 
    for c in self.children:
        result = c.apply(result)
    return result

When-Expressions

• Some actions have different effects, depending on what is already true in the world, like firing the gun which as a different effect when the gun is loaded

• We could make two actions: fire-gun-if-loaded and fire-gun-if-not-loaded, but this becomes cumbersome to write

• Instead we allow conditional effects that are only applied when a condition holds:

$$\operatorname{when}\:(\phi)\:(\psi)$$

• Note that the condition can be any logical formula, but the conditional effect has to be an effect formula

When-Expressions Example

Say we have the worlds

$$s_0 = \{\mathit{alive}(\mathit{Fred})\}\\ s_1 = \{ \mathit{alive}(\mathit{Fred}), \mathit{loaded}(\mathit{Gun}) \}$$

And the effect of the shoot action:

$$e = \operatorname{when}\:(\mathit{loaded}(\mathit{Gun}))\:(\neg \mathit{alive}(\mathit{Fred}) \wedge \neg \mathit{loaded}(\mathit{Gun})$$

What happens when we apply e to $s_0$?
What happens when we apply it to $s_1$?

When-Expressions, Implementation

• We can represent a when-expression as a tuple in the Abstract Syntax Tree ("when", x, y), where x is the condition and y is the conditional effect

• Just like with the logical connectives, we introduce a subclass of LogicalFormula that represents a when-expression

• When we apply the when-expression to a world, we apply the y-part iff the x-part holds, e.g.

class When(LogicalFormula):
   def apply(self, world):
       if self.condition.isModeledBy(world):
           return self.effect.apply(world)
       return world

References

• Logic and AI

• Online Prolog Interpreter

• The Frame Problem