Vous êtes sur la page 1sur 12

# 15-381 Artificial Intelligence

## Means-Ends Analysis and

Constraint Propagation
Jaime Carbonell
4 September 2001

Topics Covered:
Means-Ends Analysis
Search Control Rules in MEA
Constraint-Based Search

SearchPlanning:
Parameterized Operations
Multi-State Transitions
Instead of: Opi,j: Si Sj, We have Opk,l: {Sk}{ Sl}

## Preconditions and Post-Conditions

Conjunctive set of first-order predicates
Arguments can be constants or (typed) variables
Intentional description of subset of all states

## Pre-image {Sk} states where preconditions are true

Post-image {S1} states where post-conditions are true

## Requires Consistent variable bindings within and

across preconditions and post-conditions

SearchPlanning:
Parameterized Operations
First Example
OPERATOR DRIVE-CAR(<car>, <driver>, <keys>, <loc-1>)
[PRE: (AT <car> <loc-1>)
(AT <driver> <loc-1>)
(CONTAINS-GAS <car>)
(HAVE <keys> <driver>)
(CORRESPOND <keys> <car>)]
[POST: (AT <car> <loc-2>)
(AT <driver> <loc-2>)
(NOT (AT <car> <loc-1>))
(NOT (AT <driver> <loc-1>))]]

SearchPlanning:
Parameterized Operations
Second Example
(Previous example: LISP-style, Current one: PROLOG-style)
OPERATOR: move-robot(r,x,y)
TYPE:
ROBOT(r) & LOC(x) & LOC(y)
PRE:
AT(r,x) & EMPTY(y) & CONNECTED(x,y)
POST:
AT(r,y), NOT(AT(r,x))
OPERATOR: pick-up(r,z)
TYPE:
ROBOT(r) & LOC(x) & LOC(y)
PRE:
AT(r,x) & AT(z,y) & NEXT-TO(x,y) & NOT(holding(r,w,))
POST:
HOLDING(r,z)
NOT(AT(z,y))

SearchPlanning:
Parameterized Operations
Interpretation
A plan is an o-path: S0 followed by a sequence of
instantiated operators which result in the goal state.
Variables match objects in state of specified types
only for which the preconditions hold at plan
execution time.
Planning can proceed by forward or backward (or
any other) search method.
More on Planning from Veloso (later lecture)

Means-Ends Analysis
Backchaining/Subgoaling Search
1.
2.
3.
4.
5.
6.

Let Scurr:= S0
If Scurr = SG, then go to next goal (or DONE)
Let OPSapp := match(SG {POST(Opi)}) Goals(Mill(p,s), Drill(p,l,d),
Polish(p))
If OPSapp=empty, then BACKTRACK
Select OP OPSapp, (save alt's)
If match(PRE(OP), Scurr),
a. let Scurr:= apply(OP, Scurr)
b. Go to step 2

7.

## Else (i.e. if NOT(match(PRE(OP), S curr)))

a. MEA(SG):= {unmatched(PRE(OP))}, SI := Scurr)
b. If fail, backtrack
c. If succeed, apply OP as above

## Control Rules for MEA

Choice Points in MEA

## Choose Operator, if several applicable

Choose Goal, if > 1 subgoals pending
Choose Variable Bindings, if > 1 tuple

## Select choose an alternative

and eliminate other contenders
Reject Reject an alternative
and retain other contenders
Prefer Try one alternative first
and retain others for possible backtracking

## Control Rules for MEA

Example
CONTROL-RULE: Carry-before-move
TYPE:
SELECT
PRE:
Goals(Move(r,x,y), Pick-up(r,z,v)))
POST:
Pick-up(r,z)
CONTROL-RULE: Dont polish before machining
TYPE:
REJECT
PRE:
Goals(Mill(p,f), Drill(p,l,d,s), Polish(p))
POST:
Polish(p)

Constraints
Example
Find a way to fit components (1,2,3,4) into slots
(A,B,C,D) such that:

## Each slot only takes one component

Slots are in LEFT-RIGHT sequence A, B, C, D
Slots A and C are T-shaped
Slots B and D are I-shaped
Components 1,2, are 3-pronged
Components 3,4 are 2-pronged
2-pronged fit into T-shaped or I-shaped
3-pronged fit only into T-shaped
Component 3 must be LEFT of component 2

Constraints
Least Commitment Method
1.
2.
3.
4.
5.
6.
7.

## For each Variable find all legal unary-constrained

assignments.
If no assignments possible, return FAILURE
Assign most-constrained unassigned variable.
If all variables assigned, return SUCCESS
If the assigned variable is a member of a binary
constraint, propagate instantiation
Delete all residual un-viable assignments
Go to 2

Constraint-Based Search
B4

A = {1,2,3}
C = {1,2,3}
D = {3}
D3
FAILURE

A = {1,2,3,4}
B = {3,4}
C = {1,2,3,4}
D = {3,4}

B3
A = {1,2,4}
C = {1,2,4}
D = {4}
D4
A = {1,2}
C = {1,2}C = {2}
C2
A = {1}
A1
SUCCESS