Logical Agents

On knowing things…

Humans ostensibly know things

Knowing things ostensibly helps humans do things

Perhaps knowing things can help AI also do things?

Knowledge based agents use a process of reasoning on an internal representation of knowledge to know what to do.

The agents we’ve seen in Ch. 3 and 4 have knowledge, but it’s extremely limited.

What sort of things do they know?

  • What actions are available
  • The result of an action from a specific state
  • What isn’t known are general facts

Our Romania-tour agent doesn’t know a road could be negative kilometers!

Our 8-puzzle agent doesn’t know that two tiles can’t be in the same space at the same time!

These agents are specialized to find a way from a starting point, to a goal, but not much more.

What kind of representation did these agents use? What does that mean for it’s efficacy?

Explain to me how to build an agent like this that could navagate to a US city with fewer than 10,000 residents

What type of reasoning did Ch. 6 introduce?

What does this get us?

Now, let’s bring this to it’s… logical concusion.

We can develop logic as a general class of representations to support knowledge-based agents.

Just like with humans, using logic to combine and recombine information is extremely flexible.

We can explicitly define a goal for the agent to solve and the agent can deal quickly just by being told (or learning) new knowledge about the environment.

Let’s talk about agent design for a moment.

Knowledge-Based Agents

The main component of a knowledge-based agent is a… what?

The main component of a knowledge-based agent is a knowledge base (KB)

A KB is a set of sentences (nothing to do with an english sentence)

Each sentence is expressed in a language called knowledge representation language, and represents some assertion about the world (or environment)

When the sentence is presented without being derived from another sentence, it’s called an axiom

Though… we want to add or query sentences from the KB, right?

The standard names for these operations are called \(TELL\) and \(ASK\), either of which may involve inference, which derives new sentences from existing ones.

The answer to what is \(ASK\)-ed should follow from what was \(TELL\)-ed

Generic Knowlege-Based Agent

How is this similar to our other agents?

The details of the representation language is hidden inside the three functions that form the interface between the actuators and sensors.

\(MakePerceptSequence\) constructs a sentence asserting that the agent perceived the given percept at the given time.

\(MakeActionQuery\) builds the sentence that asks what should be done

\(MakeActionSentence\) constructs the sentence asserting that the action was executed

Even though this agent is similar to the internal-state agent of Ch. 2, this one only needs specification of the agent’s current knowledge and goals to specify the goal.

A taxi-agent built in this way could find paths to destinations because knows facts about it’s environment. This is independent of details on the implementaion level.

This practice of \(TELL\)-ing the agent until it can operate in the environment is called a declarative approach to programming, in contrast to a procedural approach, (these two approaches were very competitive in the 70s and 80s).

Project time!

  • Finals are on the horizon, so this class will begin transitioning to a lab-space for your final work.

  • You must select a method that we’ve looked at in the class so far and implement the requisite datastructures of your choice and the algorithm to operate on those data structures. OR to explore another topic we haven’t covered

    • Generative AI
    • Classical AI
    • Historical AI
    • AI programming languages / Systems
    • Confluence of AI with other fields

  • Your implementation should be oriented to a specific task, e.g. playing a perfect game of tic-tac-toe, solving sudoku puzzles, navagating a maze, scheduling class times, piloting a roomba, etc.

  • Your project should be something you build, not merely something you found (i.e. no presentations on using Chat-GPT)

  • Your presentation should contain a refresher/introduction to your topic, introducing/reintroducing the datastructures and algorithms from a high-level perspective. Following that, you should show your implementation (your code) and explain your your implementation details. After that, a you should showcase your running program.

  • Your project should be limited in scope, but contain enough material to demonstrate proficiency in the subject.

Before you leave:

  • Find a list of topics you are interested in

  • List the methods you could use

  • Sketch out your path to implement them