Final catch up review
This presentation is the property of its rightful owner.
Sponsored Links
1 / 95

Final Catch-up, Review PowerPoint PPT Presentation


  • 44 Views
  • Uploaded on
  • Presentation posted in: General

Final Catch-up, Review. Outline. Inference in First-Order Logic Knowledge Representation using First-Order Logic Propositional Logic Constraint Satisfaction Problems Game-Playing & Adversarial Search Questions on any topic. Review: Schematic for Follows, Entails, and Derives. Derives.

Download Presentation

Final Catch-up, Review

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Final catch up review

Final Catch-up, Review


Outline

Outline

  • Inference in First-Order Logic

  • Knowledge Representation using First-Order Logic

  • Propositional Logic

  • Constraint Satisfaction Problems

  • Game-Playing & Adversarial Search

  • Questions on any topic


Review schematic for follows entails and derives

Review: Schematic for Follows, Entails, and Derives

Derives

Inference

Sentences

Sentence

If KB is true in the real world,

then any sentence entailed by KB

and any sentence derived from KB

by a sound inference procedure

is also true in the real world.


Schematic example follows entails and derives

Schematic Example: Follows, Entails, and Derives

“Mary is Sue’s sister and Amy is Sue’s daughter.”

“Mary is Amy’s aunt.”

Derives

Inference

“An aunt is a sister of a parent.”

Is it provable?

“Mary is Sue’s sister and Amy is Sue’s daughter.”

“Mary is Amy’s aunt.”

Entails

Representation

“An aunt is a sister of a parent.”

Is it true?

Sister

Mary

Sue

Follows

Mary

World

Daughter

Is it the case?

Aunt

Amy

Amy


Inference in first order logic summary

Inference in First-Order Logic --- Summary

  • FOL inference techniques

    • Unification

    • Generalized Modus Ponens

      • Forward-chaining

      • Backward-chaining

    • Resolution-based inference

      • Refutation-complete


Unification

Unification

  • Recall: Subst(θ, p) = result of substituting θ into sentence p

  • Unify algorithm: takes 2 sentences p and q and returns a unifier if one exists

    Unify(p,q) = θ where Subst(θ, p) = Subst(θ, q)

  • Example:

    p = Knows(John,x)

    q = Knows(John, Jane)

    Unify(p,q) = {x/Jane}


Unification examples

Unification examples

  • simple example: query = Knows(John,x), i.e., who does John know?

    p q θ

    Knows(John,x) Knows(John,Jane) {x/Jane}

    Knows(John,x)Knows(y,OJ) {x/OJ,y/John}

    Knows(John,x) Knows(y,Mother(y)) {y/John,x/Mother(John)}

    Knows(John,x)Knows(x,OJ) {fail}

  • Last unification fails: only because x can’t take values John and OJ at the same time

    • But we know that if John knows x, and everyone (x) knows OJ, we should be able to infer that John knows OJ

  • Problem is due to use of same variable x in both sentences

  • Simple solution: Standardizing apart eliminates overlap of variables, e.g., Knows(z,OJ)


Unification1

Unification

  • To unify Knows(John,x) and Knows(y,z),

    θ = {y/John, x/z } or θ = {y/John, x/John, z/John}

  • The first unifier is more general than the second.

  • There is a single most general unifier (MGU) that is unique up to renaming of variables.

    MGU = { y/John, x/z }

  • General algorithm in Figure 9.1 in the text


Hard matching example

Hard matching example

  • To unify the grounded propositions with premises of the implication you need to solve a CSP!

  • Colorable() is inferred iff the CSP has a solution

  • CSPs include 3SAT as a special case, hence matching is NP-hard

Diff(wa,nt)  Diff(wa,sa)  Diff(nt,q)  Diff(nt,sa)  Diff(q,nsw)  Diff(q,sa) Diff(nsw,v)  Diff(nsw,sa) Diff(v,sa)  Colorable()

Diff(Red,Blue) Diff (Red,Green) Diff(Green,Red) Diff(Green,Blue) Diff(Blue,Red) Diff(Blue,Green)


Inference appoaches in fol

Inference appoaches in FOL

  • Forward-chaining

    • Uses GMP to add new atomic sentences

    • Useful for systems that make inferences as information streams in

    • Requires KB to be in form of first-order definite clauses

  • Backward-chaining

    • Works backwards from a query to try to construct a proof

    • Can suffer from repeated states and incompleteness

    • Useful for query-driven inference

    • Requires KB to be in form of first-order definite clauses

  • Resolution-based inference (FOL)

    • Refutation-complete for general KB

      • Can be used to confirm or refute a sentence p (but not to generate all entailed sentences)

    • Requires FOL KB to be reduced to CNF

    • Uses generalized version of propositional inference rule

  • Note that all of these methods are generalizations of their propositional equivalents


Generalized modus ponens gmp

Generalized Modus Ponens (GMP)

p1', p2', … , pn', ( p1 p2 …  pnq)

Subst(θ,q)

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)

  • Implicit assumption that all variables universally quantified

where we can unify pi‘ and pi for all i


Completeness and soundness of gmp

Completeness and Soundness of GMP

  • GMP is sound

    • Only derives sentences that are logically entailed

    • See proof in text on p. 326 (3rd ed.; p. 276, 2nd ed.)

  • GMP is complete for a KB consisting of definite clauses

    • Complete: derives all sentences that are entailed

    • OR…answers every query whose answers are entailed by such a KB

    • Definite clause: disjunction of literals of which exactly 1 is positive,

      e.g., King(x) AND Greedy(x) -> Evil(x)

      NOT(King(x)) OR NOT(Greedy(x)) OR Evil(x)


Properties of forward chaining

Properties of forward chaining

  • Sound and complete for first-order definite clauses

  • Datalog = first-order definite clauses + no functions

  • FC terminates for Datalog in finite number of iterations

  • May not terminate in general if α is not entailed

  • Incremental forward chaining: no need to match a rule on iteration k if a premise wasn't added on iteration k-1

     match each rule whose premise contains a newly added positive literal


Properties of backward chaining

Properties of backward chaining

  • Depth-first recursive proof search:

    • Space is linear in size of proof.

  • Incomplete due to infinite loops

    •  fix by checking current goal against every goal on stack

  • Inefficient due to repeated subgoals (both success and failure)

    •  fix using caching of previous results (memoization)

  • Widely used for logic programming

  • PROLOG:

    backward chaining with Horn clauses + bells & whistles.


Resolution in fol

Resolution in FOL

  • Full first-order version:

    l1···lk, m1···mn

    Subst(θ , l1···li-1li+1 ···lkm1···mj-1mj+1···mn)

    where Unify(li, mj) = θ.

  • The two clauses are assumed to be standardized apart so that they share no variables.

  • For example,

    Rich(x) Unhappy(x), Rich(Ken)

    Unhappy(Ken)

    with θ = {x/Ken}

  • Apply resolution steps to CNF(KB α); complete for FOL


Resolution proof

Resolution proof


Converting fol sentences to cnf

Converting FOL sentences to CNF

Original sentence:

Everyone who loves all animals is loved by someone:

x [y Animal(y) Loves(x,y)]  [y Loves(y,x)]

1. Eliminate biconditionals and implications

x [y Animal(y) Loves(x,y)]  [yLoves(y,x)]

2. Move  inwards:

Recall: x p ≡ x p,  x p ≡ x p

x [y (Animal(y) Loves(x,y))]  [y Loves(y,x)]

x [y Animal(y) Loves(x,y)]  [y Loves(y,x)]

x [y Animal(y) Loves(x,y)]  [y Loves(y,x)]


Conversion to cnf contd

Conversion to CNF contd.

  • Standardize variables:

    each quantifier should use a different one

    x [y Animal(y) Loves(x,y)]  [z Loves(z,x)]

    4. Skolemize: a more general form of existential instantiation.

    Each existential variable is replaced by a Skolem function of the enclosing universally quantified variables:

    x [Animal(F(x)) Loves(x,F(x))] Loves(G(x),x)

    (reason: animal y could be a different animal for each x.)


Conversion to cnf contd1

Conversion to CNF contd.

  • Drop universal quantifiers:

    [Animal(F(x)) Loves(x,F(x))] Loves(G(x),x)

    (all remaining variables assumed to be universally quantified)

    6. Distribute  over  :

    [Animal(F(x)) Loves(G(x),x)]  [Loves(x,F(x)) Loves(G(x),x)]

    Original sentence is now in CNF form – can apply same ideas to all sentences in KB to convert into CNF

    Also need to include negated query

    Then use resolution to attempt to derive the empty clause

    which show that the query is entailed by the KB


Knowledge representation using first order logic

Knowledge Representation using First-Order Logic

  • Propositional Logic is Useful --- but has Limited Expressive Power

  • First Order Predicate Calculus (FOPC), or First Order Logic (FOL).

    • FOPC has greatly expanded expressive power, though still limited.

  • New Ontology

    • The world consists of OBJECTS (for propositional logic, the world was facts).

    • OBJECTS have PROPERTIES and engage in RELATIONS and FUNCTIONS.

  • New Syntax

    • Constants, Predicates, Functions, Properties, Quantifiers.

  • New Semantics

    • Meaning of new syntax.

  • Knowledge engineering in FOL


Semantics interpretation

Semantics: Interpretation

  • An interpretation of a sentence (wff) is an assignment that maps

    • Object constant symbols to objects in the world,

    • n-ary function symbols to n-ary functions in the world,

    • n-ary relation symbols to n-ary relations in the world

  • Given an interpretation, an atomic sentence has the value “true” if it denotes a relation that holds for those individuals denoted in the terms. Otherwise it has the value “false.”

    • Example: Kinship world:

      • Symbols = Ann, Bill, Sue, Married, Parent, Child, Sibling, …

    • World consists of individuals in relations:

      • Married(Ann,Bill) is false, Parent(Bill,Sue) is true, …


Review models and in fol interpretations

Review: Models (and in FOL, Interpretations)

  • Models are formal worlds in which truth can be evaluated

  • We say mis a model of a sentence α if α is true in m

  • M(α) is the set of all models of α

  • Then KB ╞ α iff M(KB)  M(α)

    • E.g. KB, = “Mary is Sue’s sister

      and Amy is Sue’s daughter.”

    • α = “Mary is Amy’s aunt.”

  • Think of KB and α as constraints,

    and of models m as possible states.

  • M(KB) are the solutions to KB

    and M(α) the solutions to α.

  • Then, KB ╞ α, i.e., ╞ (KB  a) ,

    when all solutions to KB are also solutions to α.


Review wumpus models

Review: Wumpus models

  • KB = all possible wumpus-worlds consistent with the observations and the “physics” of the Wumpus world.


Review wumpus models1

Review: Wumpus models

α1 = "[1,2] is safe", KB ╞ α1, proved by model checking.

Every model that makes KB true also makes α1 true.


Review syntax of fol basic elements

Review: Syntax of FOL: Basic elements

  • ConstantsKingJohn, 2, UCI,...

  • PredicatesBrother, >,...

  • FunctionsSqrt, LeftLegOf,...

  • Variablesx, y, a, b,...

  • Connectives, , , , 

  • Equality=

  • Quantifiers , 


Syntax of fol basic syntax elements are symbols

Syntax of FOL: Basic syntax elements are symbols

  • Constant Symbols:

    • Stand for objects in the world.

      • E.g., KingJohn, 2, UCI, ...

  • Predicate Symbols

    • Stand for relations (maps a tuple of objects to a truth-value)

      • E.g., Brother(Richard, John), greater_than(3,2), ...

    • P(x, y) is usually read as “x is P of y.”

      • E.g., Mother(Ann, Sue) is usually “Ann is Mother of Sue.”

  • Function Symbols

    • Stand for functions (maps a tuple of objects to an object)

      • E.g., Sqrt(3), LeftLegOf(John), ...

  • Model (world)= set of domain objects, relations, functions

  • Interpretation maps symbols onto the model (world)

    • Very many interpretations are possible for each KB and world!

    • Job of the KB is to rule out models inconsistent with our knowledge.


Syntax of fol terms

Syntax of FOL: Terms

  • Term = logical expression that refers to an object

  • There are two kinds of terms:

    • Constant Symbols stand for (or name) objects:

      • E.g., KingJohn, 2, UCI, Wumpus, ...

    • Function Symbols map tuples of objects to an object:

      • E.g., LeftLeg(KingJohn), Mother(Mary), Sqrt(x)

      • This is nothing but a complicated kind of name

        • No “subroutine” call, no “return value”


Syntax of fol atomic sentences

Syntax of FOL: Atomic Sentences

  • Atomic Sentences state facts (logical truth values).

    • An atomic sentence is a Predicate symbol, optionally followed by a parenthesized list of any argument terms

    • E.g., Married( Father(Richard), Mother(John) )

    • An atomic sentence asserts that some relationship (some predicate) holds among the objects that are its arguments.

  • An Atomic Sentence is true in a given model if the relation referred to by the predicate symbol holds among the objects (terms) referred to by the arguments.


Syntax of fol connectives complex sentences

Syntax of FOL: Connectives & Complex Sentences

  • Complex Sentences are formed in the same way, and are formed using the same logical connectives, as we already know from propositional logic

  • The Logical Connectives:

    •  biconditional

    •  implication

    •  and

    •  or

    •  negation

  • Semantics for these logical connectives are the same as we already know from propositional logic.


Syntax of fol variables

Syntax of FOL: Variables

  • Variables range over objects in the world.

  • A variable is like a term because it represents an object.

  • A variable may be used wherever a term may be used.

    • Variables may be arguments to functions and predicates.

  • (A term with NO variables is called a ground term.)

  • (A variable not bound by a quantifier is called free.)


Syntax of fol logical quantifiers

Syntax of FOL: Logical Quantifiers

  • There are two Logical Quantifiers:

    • Universal:  x P(x) means “For all x, P(x).”

      • The “upside-down A” reminds you of “ALL.”

    • Existential:  x P(x) means “There exists x such that, P(x).”

      • The “upside-down E” reminds you of “EXISTS.”

  • Syntactic “sugar” --- we really only need one quantifier.

    •  x P(x)   x P(x)

    •  x P(x)   x P(x)

    • You can ALWAYS convert one quantifier to the other.

  • RULES:    and   

  • RULE: To move negation “in” across a quantifier,

    change the quantifier to “the other quantifier”

    and negate the predicate on “the other side.”

    •  x P(x)   x P(x)

    •  x P(x)   x P(x)


Combining quantifiers order scope

Combining Quantifiers --- Order (Scope)

The order of “unlike” quantifiers is important.

 x  y Loves(x,y)

  • For everyone (“all x”) there is someone (“exists y”) whom they love

  • y  x Loves(x,y)

    - there is someone (“exists y”) whom everyone loves (“all x”)

    Clearer with parentheses:  y (  x Loves(x,y) )

    The order of “like” quantifiers does not matter.

    x y P(x, y)  y x P(x, y)

    x y P(x, y)  y x P(x, y)


  • De morgan s law for quantifiers

    De Morgan’s Law for Quantifiers

    Generalized De Morgan’s Rule

    De Morgan’s Rule

    Rule is simple: if you bring a negation inside a disjunction or a conjunction,

    always switch between them (or and, and  or).


    Inference in formal symbol systems ontology representation inference

    Inference in Formal Symbol Systems:Ontology, Representation, Inference

    • Formal Symbol Systems

      • Symbols correspond to things/ideas in the world

      • Pattern matching corresponds to inference

    • Ontology: What exists in the world?

      • What must be represented?

    • Representation: Syntax vs. Semantics

      • What’s Said vs. What’s Meant

    • Inference: Schema vs. Mechanism

      • Proof Steps vs. Search Strategy


    Final catch up review

    Ontology:

    What kind of things exist in the world?

    What do we need to describe and reason about?

    Reasoning

    Representation

    -------------------

    A Formal Symbol System

    Inference

    ---------------------

    Formal Pattern Matching

    Syntax

    ---------

    What is said

    Semantics

    -------------

    What it means

    Schema

    -------------

    Rules of Inference

    Execution

    -------------

    Search Strategy

    Preceding lecture

    This lecture


    Review

    Review

    • Definitions:

      • Syntax, Semantics, Sentences, Propositions, Entails, Follows, Derives, Inference, Sound, Complete, Model, Satisfiable, Valid (or Tautology)

    • Syntactic Transformations:

      • E.g., (A  B)  (A  B)

    • Semantic Transformations:

      • E.g., (KB |= )  (|= (KB  )

    • Truth Tables

      • Negation, Conjunction, Disjunction, Implication, Equivalence (Biconditional)

      • Inference by Model Enumeration


    Review schematic perspective

    Review: Schematic perspective

    If KB is true in the real world,

    then any sentence entailed by KB

    is also true in the real world.


    So how do we keep it from just making things up

    So --- how do we keep it from“Just making things up.” ?

    “Einstein Simplified:

    Cartoons on Science”

    by Sydney Harris, 1992,

    Rutgers University Press


    Schematic perspective

    Schematic perspective

    Derives

    Inference

    Sentences

    Sentence

    If KB is true in the real world,

    then any sentence derived from KB

    by a sound inference procedure

    is also true in the real world.


    Logical inference

    Logical inference

    • The notion of entailment can be used for logic inference.

      • Model checking (see wumpus example):

        enumerate all possible models and check whether  is true.

    • Sound(or truth preserving):

      The algorithm only derives entailed sentences.

      • Otherwise it just makes things up.

        i is sound iff whenever KB |-i it is also true that KB|= 

      • E.g., model-checking is sound

    • Complete:

      The algorithm can derive every entailed sentence.

      i is complete iff whenever KB |=  it is also true that KB|-i 


    Proof methods

    Proof methods

    • Proof methods divide into (roughly) two kinds:

      Application of inference rules:

      Legitimate (sound) generation of new sentences from old.

      • Resolution

      • Forward & Backward chaining

        Model checking

        Searching through truth assignments.

        • Improved backtracking: Davis--Putnam-Logemann-Loveland (DPLL)

        • Heuristic search in model space: Walksat.


    Propositional logic summary

    Propositional Logic --- Summary

    • Logical agents apply inference to a knowledge base to derive new information and make decisions

    • Basic concepts of logic:

      • syntax: formal structure of sentences

      • semantics: truth of sentences wrt models

      • entailment: necessary truth of one sentence given another

      • inference: deriving sentences from other sentences

      • soundness: derivations produce only entailed sentences

      • completeness: derivations can produce all entailed sentences

      • valid: sentence is true in every model (a tautology)

    • Logical equivalences allow syntactic manipulations

    • Propositional logic lacks expressive power

      • Can only state specific facts about the world.

      • Cannot express general rules about the world (use First Order Predicate Logic)


    Propositional logic review

    Propositional Logic --- Review

    • Definitions:

      • Syntax, Semantics, Sentences, Propositions, Entails, Follows, Derives, Inference, Sound, Complete, Model, Satisfiable, Valid (or Tautology)

    • Syntactic Transformations:

      • E.g., (A  B)  (A  B)

    • Semantic Transformations:

      • E.g., (KB |= )  (|= (KB  )

    • Truth Tables

      • Negation, Conjunction, Disjunction, Implication, Equivalence (Biconditional)

      • Inference by Model Enumeration


    Entailment

    Entailment

    • Entailment means that one thing follows from another:

      KB ╞ α

    • Knowledge base KB entails sentence α if and only if α is true in all worlds where KB is true

      • E.g., the KB containing “the Giants won and the Reds won” entails “The Giants won”.

      • E.g., x+y = 4 entails 4 = x+y

      • E.g., “Mary is Sue’s sister and Amy is Sue’s daughter” entails “Mary is Amy’s aunt.”


    Models

    Models

    • Logicians typically think in terms of models, which are formally structured worlds with respect to which truth can be evaluated

    • We say mis a model of a sentence α if α is true in m

    • M(α) is the set of all models of α

    • Then KB ╞ α iff M(KB)  M(α)

      • E.g. KB = Giants won and Redswon α = Giants won

    • Think of KB and α as collections of

      constraints and of models m as

      possible states. M(KB) are the solutions

      to KB and M(α) the solutions to α.

      Then, KB ╞ α when all solutions to

      KB are also solutions to α.


    Logical inference1

    Logical inference

    • The notion of entailment can be used for logic inference.

      • Model checking (see wumpus example):

        enumerate all possible models and check whether  is true.

    • Sound(or truth preserving):

      The algorithm only derives entailed sentences.

      • Otherwise it just makes things up.

        i is sound iff whenever KB |-i it is also true that KB|= 

      • E.g., model-checking is sound

    • Complete:

      The algorithm can derive every entailed sentence.

      i is complete iff whenever KB |=  it is also true that KB|-i 


    Inference procedures

    Inference Procedures

    • KB ├i α = sentence α can be derived from KB by procedure i

    • Soundness: i is sound if whenever KB ├i α, it is also true that KB╞ α (no wrong inferences, but maybe not all inferences)

    • Completeness: i is complete if whenever KB╞ α, it is also true that KB ├i α (all inferences can be made, but maybe some wrong extra ones as well)


    Recap propositional logic syntax

    Recap propositional logic: Syntax

    • Propositional logic is the simplest logic – illustrates basic ideas

    • The proposition symbols P1, P2 etc are sentences

      • If S is a sentence, S is a sentence (negation)

      • If S1 and S2 are sentences, S1 S2 is a sentence (conjunction)

      • If S1 and S2 are sentences, S1 S2 is a sentence (disjunction)

      • If S1 and S2 are sentences, S1 S2 is a sentence (implication)

      • If S1 and S2 are sentences, S1 S2 is a sentence (biconditional)


    Recap propositional logic semantics

    Recap propositional logic: Semantics

    Each model/world specifies true or false for each proposition symbol

    E.g. P1,2 P2,2 P3,1

    falsetruefalse

    With these symbols, 8 possible models, can be enumerated automatically.

    Rules for evaluating truth with respect to a model m:

    Sis true iff S is false

    S1 S2 is true iff S1 is true and S2 is true

    S1 S2 is true iff S1is true or S2 is true

    S1 S2 is true iffS1 is false orS2 is true

    i.e., is false iffS1 is true andS2 is false

    S1 S2is true iffS1S2 is true andS2S1 is true

    Simple recursive process evaluates an arbitrary sentence, e.g.,

    P1,2  (P2,2 P3,1) = true (true  false) = true true = true


    Recap truth tables for connectives

    Recap truth tables for connectives

    Implication is always true

    when the premises are False!

    OR: P or Q is true or both are true.

    XOR: P or Q is true but not both.


    Inference by enumeration

    Inference by enumeration

    • Enumeration of all models is sound and complete.

    • For n symbols, time complexity is O(2n)...

    • We need a smarter way to do inference!

    • In particular, we are going to infer new logical sentences from the data-base and see if they match a query.


    Logical equivalence

    Logical equivalence

    • To manipulate logical sentences we need some rewrite rules.

    • Two sentences are logically equivalent iff they are true in same models: α ≡ ß iff α╞ β and β╞ α

    You need to

    know these !


    Validity and satisfiability

    Validity and satisfiability

    A sentence is valid if it is true in all models,

    e.g., True,A A, A  A, (A  (A  B))  B

    Validity is connected to inference via the Deduction Theorem:

    KB ╞ α if and only if (KB α) is valid

    A sentence is satisfiable if it is true in some model

    e.g., A B, C

    A sentence is unsatisfiable if it is false in all models

    e.g., AA

    Satisfiability is connected to inference via the following:

    KB ╞ α if and only if (KBα) is unsatisfiable

    (there is no model for which KB=true and is false)


    Propositional logic summary1

    Propositional Logic --- Summary

    • Logical agents apply inference to a knowledge base to derive new information and make decisions

    • Basic concepts of logic:

      • syntax: formal structure of sentences

      • semantics: truth of sentences wrt models

      • entailment: necessary truth of one sentence given another

      • inference: deriving sentences from other sentences

      • soundness: derivations produce only entailed sentences

      • completeness: derivations can produce all entailed sentences

    • Resolution is refutation complete for propositional logic.Forward and backward chaining are linear-time, complete for Horn clauses

    • Propositional logic lacks expressive power


    Constraint satisfaction problems

    Constraint Satisfaction Problems

    • What is a CSP?

      • Finite set of variables X1, X2, …, Xn

      • Nonempty domain of possible values for each variable D1, D2, …, Dn

      • Finite set of constraints C1, C2, …, Cm

        • Each constraint Ci limits the values that variables can take,

        • e.g., X1 ≠ X2

      • Each constraint Ci is a pair <scope, relation>

        • Scope = Tuple of variables that participate in the constraint.

        • Relation = List of allowed combinations of variable values.

          May be an explicit list of allowed combinations.

          May be an abstract relation allowing membership testing and listing.

    • CSP benefits

      • Standard representation pattern

      • Generic goal and successor functions

      • Generic heuristics (no domain specific expertise).


    Csps what is a solution

    CSPs --- what is a solution?

    • A state is an assignment of values to some or all variables.

      • An assignment is complete when every variable has a value.

      • An assignment is partial when some variables have no values.

    • Consistent assignment

      • assignment does not violate the constraints

    • A solution to a CSP is a complete and consistent assignment.

    • Some CSPs require a solution that maximizes an objective function.


    Csp as a standard search problem

    CSP as a standard search problem

    • A CSP can easily be expressed as a standard search problem.

    • Incremental formulation

      • Initial State: the empty assignment {}

      • Actions (3rd ed.), Successor function (2nd ed.): Assign a value to an unassigned variable provided that it does not violate a constraint

      • Goal test: the current assignment is complete

        (by construction it is consistent)

      • Path cost: constant cost for every step (not really relevant)

    • Can also use complete-state formulation

      • Local search techniques (Chapter 4) tend to work well


    Improving csp efficiency

    Improving CSP efficiency

    • Previous improvements on uninformed search

       introduce heuristics

    • For CSPS, general-purpose methods can give large gains in speed, e.g.,

      • Which variable should be assigned next?

      • In what order should its values be tried?

      • Can we detect inevitable failure early?

      • Can we take advantage of problem structure?

        Note: CSPs are somewhat generic in their formulation, and so the heuristics are more general compared to methods in Chapter 4


    Minimum remaining values mrv

    Minimum remaining values (MRV)

    var SELECT-UNASSIGNED-VARIABLE(VARIABLES[csp],assignment,csp)

    • A.k.a. most constrained variable heuristic

    • Heuristic Rule: choose variable with the fewest legal moves

      • e.g., will immediately detect failure if X has no legal values


    Degree heuristic for the initial variable

    Degree heuristic for the initial variable

    • Heuristic Rule: select variable that is involved in the largest number of constraints on other unassigned variables.

    • Degree heuristic can be useful as a tie breaker.

    • In what order should a variable’s values be tried?


    Least constraining value for value ordering

    Least constraining value for value-ordering

    • Least constraining value heuristic

    • Heuristic Rule: given a variable choose the least constraining value

      • leaves the maximum flexibility for subsequent variable assignments


    Forward checking

    Forward checking

    • Assign {Q=green}

    • Effects on other variables connected by constraints with WA

      • NT can no longer be green

      • NSW can no longer be green

      • SA can no longer be green

    • MRV heuristic would automatically select NT or SA next


    Forward checking1

    Forward checking

    • If V is assigned blue

    • Effects on other variables connected by constraints with WA

      • NSW can no longer be blue

      • SA is empty

    • FC has detected that partial assignment is inconsistent with the constraints and backtracking can occur.


    Arc consistency

    Arc consistency

    • An Arc X  Y is consistent if

      for every value x of X there is some value y consistent with x

      (note that this is a directed property)

    • Consider state of search after WA and Q are assigned:

      SA  NSW is consistent if

      SA=blue and NSW=red


    Arc consistency1

    Arc consistency

    • X  Y is consistent if

      for every value x of X there is some value y consistent with x

    • NSW  SA is consistent if

      NSW=red and SA=blue

      NSW=blue and SA=???


    Arc consistency2

    Arc consistency

    • Can enforce arc-consistency:

      Arc can be made consistent by removing blue from NSW

    • Continue to propagate constraints….

      • Check V  NSW

      • Not consistent for V = red

      • Remove red from V


    Arc consistency3

    Arc consistency

    • Continue to propagate constraints….

    • SA  NT is not consistent

      • and cannot be made consistent

    • Arc consistency detects failure earlier than FC


    Arc consistency algorithm ac 3

    Arc consistency algorithm (AC-3)

    function AC-3(csp) return the CSP, possibly with reduced domains

    inputs: csp, a binary csp with variables {X1, X2, …, Xn}

    local variables: queue, a queue of arcs initially the arcs in csp

    while queue is not empty do

    (Xi, Xj)  REMOVE-FIRST(queue)

    if REMOVE-INCONSISTENT-VALUES(Xi, Xj)then

    for each Xkin NEIGHBORS[Xi] do

    add (Xi, Xj) to queue

    function REMOVE-INCONSISTENT-VALUES(Xi, Xj) returntrue iff we remove a value

    removed false

    for eachxin DOMAIN[Xi] do

    if no value y inDOMAIN[Xj]allows (x,y) to satisfy the constraints between Xi and Xj

    then delete x from DOMAIN[Xi]; removed true

    return removed

    (from Mackworth, 1977)


    Local search for csp

    Local search for CSP

    function MIN-CONFLICTS(csp, max_steps) return solution or failure

    inputs: csp, a constraint satisfaction problem

    max_steps, the number of steps allowed before giving up

    current an initial complete assignment for csp

    for i= 1 to max_stepsdo

    ifcurrent is a solution for csp then return current

    var a randomly chosen, conflicted variable from VARIABLES[csp]

    value the value v for var that minimize CONFLICTS(var,v,current,csp)

    set var = value in current

    return failure


    Graph structure and problem complexity

    Graph structure and problem complexity

    • Solving disconnected subproblems

      • Suppose each subproblem has c variables out of a total of n.

      • Worst case solution cost is O(n/c dc), i.e. linear in n

        • Instead of O(d n), exponential in n

    • E.g. n= 80, c= 20, d=2

      • 280 = 4 billion years at 1 million nodes/sec.

      • 4 * 220= .4 second at 1 million nodes/sec


    Tree structured csps

    Tree-structured CSPs

    • Theorem:

      • if a constraint graph has no loops then the CSP can be solved in O(nd 2) time

      • linear in the number of variables!

    • Compare difference with general CSP, where worst case is O(d n)


    Algorithm for solving tree structured csps

    Algorithm for Solving Tree-structured CSPs

    • Choose some variable as root, order variables from root to leaves such that

      every node’s parent precedes it in the ordering.

      • Label variables from X1 to Xn)

      • Every variable now has 1 parent

    • Backward Pass

      • For j from n down to 2, apply arc consistency to arc [Parent(Xj), Xj) ]

      • Remove values from Parent(Xj) if needed

    • Forward Pass

      • For j from 1 to n assign Xj consistently with Parent(Xj )


    Tree csp complexity

    Tree CSP complexity

    • Backward pass

      • n arc checks

      • Each has complexity d2 at worst

    • Forward pass

      • n variable assignments, O(nd)

      • Overall complexity is O(nd 2)

        Algorithm works because if the backward pass succeeds, then every variable by definition has a legal assignment in the forward pass


    What about non tree csps

    What about non-tree CSPs?

    • General idea is to convert the graph to a tree

      2 general approaches

    • Assign values to specific variables (Cycle Cutset method)

    • Construct a tree-decomposition of the graph

      - Connected subproblems (subgraphs) form a tree structure


    Cycle cutset conditioning

    Cycle-cutset conditioning

    • Choose a subset S of variables from the graph so that graph without S is a tree

      • S = “cycle cutset”

    • For each possible consistent assignment for S

      • Remove any inconsistent values from remaining variables that are inconsistent with S

      • Use tree-structured CSP to solve the remaining tree-structure

        • If it has a solution, return it along with S

        • If not, continue to try other assignments for S


    Tree decompositions

    Tree Decompositions


    Rules for a tree decomposition

    Rules for a Tree Decomposition

    • Every variable appears in at least one of the subproblems

    • If two variables are connected in the original problem, they must appear together (with the constraint) in at least one subproblem

    • If a variable appears in two subproblems, it must appear in each node on the path connecting those subproblems.


    Summary

    Summary

    • CSPs

      • special kind of problem: states defined by values of a fixed set of variables, goal test defined by constraints on variable values

    • Backtracking=depth-first search with one variable assigned per node

    • Heuristics

      • Variable ordering and value selection heuristics help significantly

    • Constraint propagation does additional work to constrain values and detect inconsistencies

      • Works effectively when combined with heuristics

    • Iterative min-conflicts is often effective in practice.

    • Graph structure of CSPs determines problem complexity

      • e.g., tree structured CSPs can be solved in linear time.


    Game playing adversarial search overview

    Game-Playing & Adversarial Search --- Overview

    • Minimax Search with Perfect Decisions

      • Impractical in most cases, but theoretical basis for analysis

    • Minimax Search with Cut-off

      • Replace terminal leaf utility by heuristic evaluation function

    • Alpha-Beta Pruning

      • The fact of the adversary leads to an advantage in search!

    • Practical Considerations

      • Redundant path elimination, look-up tables, etc.

    • Game Search with Chance

      • Expectiminimax search


    Games as search

    Games as Search

    • Two players: MAX and MIN

    • MAX moves first and they take turns until the game is over

      • Winner gets reward, loser gets penalty.

      • “Zero sum” means the sum of the reward and the penalty is a constant.

    • Formal definition as a search problem:

      • Initial state: Set-up specified by the rules, e.g., initial board configuration of chess.

      • Player(s): Defines which player has the move in a state.

      • Actions(s): Returns the set of legal moves in a state.

      • Result(s,a): Transition model defines the result of a move.

      • (2nd ed.: Successor function: list of (move,state) pairs specifying legal moves.)

      • Terminal-Test(s): Is the game finished? True if finished, false otherwise.

      • Utility function(s,p): Gives numerical value of terminal state s for player p.

        • E.g., win (+1), lose (-1), and draw (0) in tic-tac-toe.

        • E.g., win (+1), lose (0), and draw (1/2) in chess.

    • MAX uses search tree to determine next move.


    An optimal procedure the min max method

    An optimal procedure: The Min-Max method

    Designed to find the optimal strategy for Max and find best move:

    • 1. Generate the whole game tree, down to the leaves.

    • 2. Apply utility (payoff) function to each leaf.

    • 3. Back-up values from leaves through branch nodes:

      • a Max node computes the Max of its child values

      • a Min node computes the Min of its child values

    • 4. At root: choose the move leading to the child of highest value.


    Game trees

    Game Trees


    Pseudocode for minimax algorithm

    Pseudocode for Minimax Algorithm

    function MINIMAX-DECISION(state) returns an action

    inputs: state, current state in game

    return argmaxaActions(state) Min-Value(Result(state,a))

    function MAX-VALUE(state) returns a utility value

    if TERMINAL-TEST(state) then return UTILITY(state)

    v  −∞

    for a in ACTIONS(state) do

    v MAX(v,MIN-VALUE(Result(state,a)))

    return v

    function MIN-VALUE(state) returns a utility value

    if TERMINAL-TEST(state) then return UTILITY(state)

    v  +∞

    for a in ACTIONS(state) do

    v MIN(v,MAX-VALUE(Result(state,a)))

    return v


    Properties of minimax

    Properties of minimax

    • Complete?

      • Yes (if tree is finite).

    • Optimal?

      • Yes (against an optimal opponent).Can it be beaten by an opponent playing sub-optimally?

        • No. (Why not?)

    • Time complexity?

      • O(bm)

    • Space complexity?

      • O(bm) (depth-first search, generate all actions at once)

      • O(m) (depth-first search, generate actions one at a time)


    Static heuristic evaluation functions

    Static (Heuristic) Evaluation Functions

    • An Evaluation Function:

      • Estimates how good the current board configuration is for a player.

      • Typically, evaluate how good it is for the player, how good it is for the opponent, then subtract the opponent’s score from the player’s.

      • Othello: Number of white pieces - Number of black pieces

      • Chess: Value of all white pieces - Value of all black pieces

    • Typical values from -infinity (loss) to +infinity (win) or [-1, +1].

    • If the board evaluation is X for a player, it’s -X for the opponent

      • “Zero-sum game”


    General alpha beta pruning

    General alpha-beta pruning

    • Consider a node n in the tree ---

    • If player has a better choice at:

      • Parent node of n

      • Or any choice point further up

    • Then n will never be reached in play.

    • Hence, when that much is known about n, it can be pruned.


    Alpha beta algorithm

    Alpha-beta Algorithm

    • Depth first search

      • only considers nodes along a single path from root at any time

        a = highest-value choice found at any choice point of path for MAX

        (initially, a = −infinity)

        b = lowest-value choice found at any choice point of path for MIN

        (initially,  = +infinity)

    • Pass current values of a and b down to child nodes during search.

    • Update values of a and b during search:

      • MAX updates  at MAX nodes

      • MIN updates  at MIN nodes

    • Prune remaining branches at a node when a ≥ b


    When to prune

    When to Prune

    • Prune whenever  ≥ .

      • Prune below a Max node whose alpha value becomes greater than or equal to the beta value of its ancestors.

        • Max nodes update alpha based on children’s returned values.

      • Prune below a Min node whose beta value becomes less than or equal to the alpha value of its ancestors.

        • Min nodes update beta based on children’s returned values.


    Effectiveness of alpha beta search

    Effectiveness of Alpha-Beta Search

    • Worst-Case

      • branches are ordered so that no pruning takes place. In this case alpha-beta gives no improvement over exhaustive search

    • Best-Case

      • each player’s best move is the left-most child (i.e., evaluated first)

      • in practice, performance is closer to best rather than worst-case

      • E.g., sort moves by the remembered move values found last time.

      • E.g., expand captures first, then threats, then forward moves, etc.

      • E.g., run Iterative Deepening search, sort by value last iteration.

    • In practice often get O(b(d/2)) rather than O(bd)

      • this is the same as having a branching factor of sqrt(b),

        • (sqrt(b))d = b(d/2),i.e., we effectively go from b to square root of b

      • e.g., in chess go from b ~ 35 to b ~ 6

        • this permits much deeper search in the same amount of time


    Game playing adversarial search summary

    Game-Playing & Adversarial Search --- Summary

    • Game playing is best modeled as a search problem

    • Game trees represent alternate computer/opponent moves

    • Evaluation functions estimate the quality of a given board configuration for the Max player.

    • Minimax is a procedure which chooses moves by assuming that the opponent will always choose the move which is best for them

    • Alpha-Beta is a procedure which can prune large parts of the search tree and allow search to go deeper

    • For many well-known games, computer algorithms based on heuristic search match or out-perform human world experts.


    Outline1

    Outline

    • Inference in First-Order Logic

    • Knowledge Representation using First-Order Logic

    • Propositional Logic

    • Constraint Satisfaction Problems

    • Game-Playing & Adversarial Search

    • Questions on any topic


  • Login