3-1

Chapter 3 DEDUCTIVE REASONING AGENTS

3-2

Agent Architectures An agent is a computer system capable of

flexible autonomous action… Issues one needs to address in order to build

agent-based systems… Three types of agent architecture:

symbolic/logical (theorem proving, prolog-like) reactive (no model of world) hybrid (mixture of the two)

3-3

Agent Architectures

Kaelbling considers an agent architecture to be:‘[A] specific collection of software (or hardware) modules, typically designated by boxes with arrows indicating the data and control flow among the modules. A more abstract view of an architecture is as a general methodology for designing particular modular decompositions for particular tasks.’

3-4

Agent Architectures Originally (1956-1985), pretty much all agents

designed within AI were symbolic reasoning agents Its purest expression proposes that agents use explicit

logical reasoning in order to decide what to do Problems with symbolic reasoning led to a reaction

against this — the so-called reactive agents movement, 1985–present. What were these problems?

From 1990-present, a number of alternatives proposed: hybrid architectures, which attempt to combine the best of reasoning and reactive architectures

3-5

Symbolic Reasoning Agents The classical approach to building agents is to view

them as a particular type of knowledge-based system, and bring all the associated (discredited?!) methodologies of such systems to bear

This paradigm is known as symbolic AI (similar to Prolog)

We define a deliberative agent or agent architecture to be one that: contains an explicitly represented, symbolic model of the

world makes decisions (for example about what actions to

perform) via symbolic reasoning

3-6

Symbolic Reasoning Agents If we aim to build an agent in this way, there are two

key problems to be solved:1. The transduction problem:

that of translating the real world into an accurate, adequate symbolic description, in time for that description to be useful…vision, speech understanding, learning

2. The representation/reasoning problem:that of how to symbolically represent information about complex real-world entities and processes, and how to get agents to reason with this information in time for the results to be useful…knowledge representation, automated reasoning, automatic planning

3-7

Example – strips planner A linear planner is one in which the order in which subproblems are solved is linearly related to the order in which the actions of the plan are executed.

Divide and conquer: to create a plan to achieve aconjunction of goals, create a plan to achieve one

goal, and then create a plan to achieve the rest of the goals.

To achieve a list of goals: choose one of them to achieve. If it is not already achieved

choose an action that makes the goal true achieve the preconditions of the action

carry out the action achieve the rest of the goals.

3-8

Look at Strips Planner handout

3-9

Undoing Achieved Goals

Example: consider trying to achieve achieve_all([carrying(fred,gift), agent_at(fred,lab2)],

init, S, 18, N). Example: consider trying to achieve achieve_all([agent_at(fred,lab2),agent_at(fred,lab1)]

, init, S, 18, N).

The STRIPS algorithm, as presented, is unsound.

Achieving one subgoal may undo already achieved

subgoals.

3-10

I have made all “adjacencies” two way… S = do(move(fred, lab2, lab1), do(unlock(fred,

door2), do(move(fred, usu, lab2), do(unlock(fred, door1), do(move(fred, mail, usu), do(pickup(fred, key1, mail), do(pickup(fred, money, mail), do(pickup(fred, key2, mail), do(move(fred, bank, mail), do(move(fred, lounge, bank), do(move(fred, downtown, lounge), do(move(fred, usu, downtown), do(move(fred, downtown, usu), do(move(fred, usu, downtown), do(move(fred, downtown, usu), do(move(fred, usu, downtown), do(move(fred, lab2, usu), init)))))))))))))))))

N = 1

3-11

Goal: get to lab, but must have key and money to get in.

pre-conditions and post-conditions, threats. You would have to keep a list of conditions

that you cannot alter. Then “threats” would tell you if you would undo conditions you’ve already achieved.

You can have conflicting goals.

3-12

Symbolic Reasoning Agents Most researchers accept that neither problem

(transduction or reasoning) is anywhere near solved Underlying problem lies with the complexity of

symbol manipulation algorithms in general: many (most) search-based symbol manipulation algorithms of interest are highly intractable

Because of these problems, some researchers have looked to alternative techniques for building agents;

Attractive, however, as the rules are executed (an executable specification) directly to produce the agents behavior

3-13

Deductive Reasoning Agents Basic idea is to use logic to encode a theory

stating the best action to perform in any given situation

Let: be this theory (typically a set of rules) be a logical database that describes the current

state of the world Ac be the set of actions the agent can perform ├ mean that can be proved from using

3-14

Deductive Reasoning Agents/* first try to find an action explicitly prescribed Brute force. Examine all choices to see where they lead*/for each a Ac do

if ├ Do(a) then /* action is to be done */return a

end-ifend-for/* if that doesn’t work, try to find an action not excluded */for each a Ac do

if (not)├ Do(a) thenreturn a

end-ifend-forreturn null /* no action found */

3-15

Planning Systems (in general) Planning systems find a sequence of actions

that transforms an initial state into a goal state

I G

a1

a17

a142

3-16

We see the un-directed (aimless?) branching behavior as the strips planner kept repeating what it had already done – going between two locations cyclically – because it could.

3-17

The Blocks World

The Blocks World (version 0) consists of equal sized blocks on a table

A robot arm can manipulate the blocks using the actions: UNSTACK(a, b) STACK(a, b) PICKUP(a) PUTDOWN(a)

3-18

The Blocks World We also use predicates to describe the world:

ON(A,B) ONTABLE(B) ONTABLE(C) CLEAR(A) CLEAR(C) ARMEMPTY

A

B C

3-19

Logical Formulas to Describe Facts Always True of the World And of course we can write general logical

truths relating the predicates:

[ x HOLDING(x) ] ¬ ARMEMPTY

x [ ONTABLE(x) ¬ y [ON(x,y)] ]

x [ ¬ y [ON(y, x)] CLEAR(x) ]

So…how do we use theorem-proving techniques to construct plans?

3-20

Green’s Method Basically this states that we note the changes to a state

produced by the application of a rule. Since Green's method is based on resolution, the following

strong properties can be proved: the method is sound in that it produces only correct plans; and

it is complete in that it is guaranteed to produce a correct plan whenever one exists.

There is no restriction about the type of plan involved: we use it in creation of action blocks and conditional programs

Add state variables to the predicates, and use a function DO that maps actions and states into new states

DO: A x S S

Example:DO(UNSTACK(x, y), S) is a new state

A series of actions result in a state such as DO(PICKUP(y),DO( PUTDOWN(x),DO(UNSTACK(x, y),init)))

3-21

UNSTACK So to characterize the action UNSTACK we

could write:[ CLEAR(x, s) ON(x, y, s) ] [HOLDING(x, DO(UNSTACK(x,y),s)) CLEAR(y, DO(UNSTACK(x,y),s))]

We can prove what the new state is in terms of the old state.

A

B

3-22

COMPONENTS Of Planning

1 choose the best rule based upon heuristics 2 apply this rule to create a new state 3 detect when a solution is found 4 detect dead ends so that they can be

avoided 5 detect when a nearly solved state occurs &

use special methods to make it a solved state

3-23

Methods used find the differences between the current states and

the goal states and then choosing the rules that reduce these differences (means end analysis).

Example If we wish to travel by car to visit a friend the first

thing to do is to fill up the car with fuel. If we do not have a car then we need to acquire

one. The largest difference must be tackled first. To travel by car requires fuel, but if the vehicle is

not there acquire the vehicle. If you can’t acquire the car, there is no reason to

worry about fuel.

3-24

Problems with Green’s method The frame problem

In the above we know that B is still on the table. This needs to be encoded into frame axioms that describe components of the state not affected by the operator.

The qualification problem If we resolve the frame problem the resulting description may still

be inadequate. Do we need to encode that a block cannot be placed on top of itself?

The ramification problem After unstacking block A, previously, how do we know that A is

no longer at its initial location? Not only is it hard to specify exactly what does not happen ( frame problem) it is hard to specify exactly what does happen.

3-25

The Frame Problem Basically each operator has three lists of

predicates associated with it, the first is a list of things that become true called ACHIEVES and the second are things that become false called DELETE. The third list is a set of PRECONDITIONS that must be true before the operator can be applied. Anything not in these lists is assumed to be unaffected by the operation.

3-26

Planning Agents Since the early 1970s, the AI planning community has been

closely concerned with the design of artificial agents Planning is essentially automatic programming: the design of

a course of action that will achieve some desired goal Within the symbolic AI community, it has long been assumed

that some form of AI planning system will be a central component of any artificial agent

But in the mid 1980s, Chapman established some theoretical results which indicate that AI planners will ultimately turn out to be unusable in any time-constrained system

3-27

Attempts at specifying reasoning

3-28

AGENT0 AGENT0 is implemented as an extension to

LISP Each agent in AGENT0 has 4 components:

a set of capabilities (things the agent can do) a set of initial beliefs a set of initial commitments (things the agent will

do) a set of commitment rules

The key component, which determines how the agent acts, is the commitment rule set

3-29

AGENT0 Each commitment rule contains

a message condition (request) a mental condition (precondition) an action

On each ‘agent cycle’… If the rule fires, then the agent becomes

committed to the action (the action gets added to the agent’s commitment set)

3-30

AGENT0 – early prototype language Actions may be

private: an internally executed computation, or communicative: sending messages

Messages are constrained to be one of three types: “requests” to commit to action “unrequests” to refrain from actions “informs” which pass on information

3-31

AGENT0

3-32

AGENT0 A commitment rule:COMMIT( /* request from agent1 asking Do */

( agent1, REQUEST, DO(time, action)), ;;; msg condition( B, Beliefs

[now, Friend agent1] ANDCAN(self, action) ANDNOT [time, CMT(self,

anyaction)]), ;;; mental conditionself,DO(time, action)

)

3-33

AGENT0

This rule may be paraphrased as follows:if I receive a message from agent which requests me to do action at time, and I believe that: agent is currently a friend I can do the action At time, I am not committed to doing any other

action

then commit to doing action at time

3-34

Concurrent METATEM Concurrent METATEM is a multi-agent

language in which each agent is programmed by giving it a temporal logic specification of the behavior it should exhibit

These specifications are executed directly in order to generate the behavior of the agent.

Engine which runs the agent is distinct from the rules. Easy to modify.

Temporal logic is classical logic augmented by modal operators for describing how the truth of propositions changes over time

3-35

Temporal Logic

propositions qualified in terms of time first studied by Aristotle Amir Pnueli (turing award 1996), Zohar

Manna We know how to deal with true or false I am hungry – varies over time.

hungry now always be hungry I will be hungry until I eat something

3-36

Used in Formal Verification

In systems work request will eventually be granted resource never granted to two requestors

simultaneously Reasons about a timeline In Branching logic (future worlds), reasons

about multiple time lines.

3-37

Notation varies between sources

3-38

Concurrent METATEM For example. . .

important(agents)means “it is now, and will always be true that agents are important”

important(ConcurrentMetateM)means “sometime in the future, ConcurrentMetateM will be important”

important(Prolog)means “sometime in the past it was true that Prolog was important”

(friends(us)) U apologize(you)means “we are not friends until you apologize”

apologize(you)means “tomorrow (in the next state), you apologize”.

3-39

Concurrent METATEM MetateM is a framework for directly executing temporal

logic specifications The root of the MetateM concept is Gabbay’s separation

theorem:Any arbitrary temporal logic formula can be rewritten in a logically equivalent past future form.

This past future form can be used as execution rules A MetateM program is a set of such rules Execution proceeds by a process of continually matching

rules against a “history”, and firing those rules whose antecedents are satisfied

The future-time consequents become commitments which must subsequently be satisfied

3-40

Concurrent METATEM An example MetateM program: the resource

controller…

First rule ensure that an ‘ask’ is eventually followed by a ‘give’

Second rule ensures that only one ‘give’ is ever performed at any one time

There are algorithms for executing MetateM programs that appear to give reasonable performance

Rules are independentVariables are universally quantified

3-41

Concurrent METATEM For example, a ‘stack’ object’s interface:

stack(pop, push)[popped, stackfull]

{pop, push} = inputs{popped, stackfull} = outputs

3-42

Concurrent METATEM To illustrate the language Concurrent MetateM in more

detail, here are some example programs… Snow White has some sweets (resources), which she will

give to the Dwarves (resource consumers) Here is Snow White, written in Concurrent MetateM:

What does this mean?

(inputs) [output]

x,y are dwarfs

With no temporal qualifier,we mean NOW

3-43

She will always eventually give to a dwarf that asks She will only give to one dwarf at a time

3-44

Concurrent METATEM

The dwarf ‘eager’ asks for a sweet initially, and then whenever he has just received one, asks again

Some dwarves are even less polite: ‘greedy’ just asks every time

3-45

Concurrent METATEM Try at seats… Pavlov will ask once, but only asks again

(eventually) if he gets something. Shadow will ask immediately after his friend Pavlov

asks. Fortunately, some have better manners; ‘courteous’

only asks when ‘eager’ and ‘greedy’ have eaten

‘shy’ will only ask for a sweet when no-one else has just asked

3-46

Concurrent METATEM Try at seats… Fortunately, some have better manners;

‘courteous’ only asks when ‘eager’ and ‘greedy’ have eaten

‘shy’ will only ask for a sweet when no-one else has just asked