Okay, let's start.

Yesterday, we talked about first order logic.

And the idea was that we design agents, in this case logic based agents that use some kind of a formal language and formal inference procedure for their world modeling and keeping and maintaining the world model.

We have the choice of which language to take.

And normally if you do these things, you will actually design a logic and an inference system for the particular world that is well adapted to them.

And the inference system has the characteristics you need.

Of course I cannot show you every logic, especially the ones we still have to invent.

But I can show you two paradigmatic logics.

One is propositional logic, which is designed to be extremely simple to have decision procedures for satisfiability and to be very efficiently handleable by by algorithms.

First order logic, kind of at the other extreme, it's in a way, the most expressive logics.

And expressivity is good because it allows us to describe complex things in the world compactly.

And if our formulae are compact, that's good for inference.

Because dealing with small things is much better than dealing with big things.

And so logic is at the other extreme.

It's kind of the strongest logic that we can use without losing certain properties.

And those properties are that we have sound and complete calcali.

And when we have sound and complete calcali, that means we can have semi decision procedures for satisfiability.

Semi decision procedure means if a set is satisfiable, then we can find out in finite time.

If it's not, it might run forever.

So that's kind of undecidability is a fact of life for strong logics.

We're losing the good property of decidability we had for propositional logic.

But we can express things much more succinctly and in a much more structured way.

And more structure in your expression often means more guided inference.

So there's a trade-off.

And sometimes first-order logic wins.

And sometimes propositional logic wins depending on what kind of an agent you want to do.

And there's all kinds of logics in between.

There are logics which are decidable like propositional logic, but look very much like first-order logic.

You're just leaving out the stuff that causes you pain and suffering.

And you have to decide, can I express the world I want to talk about in that decidable fragment or not as an agent designer?

I want to show you the kind of extreme.

We'll go over it relatively quickly because you've already seen it.

We've made this experiment talking about blocks.

And that was mainly to show you we need to say something like all blocks.

And this doesn't move anymore. Why not?

Well, okay. Probably need new batteries.

Right. We need to say something. All blocks are something or the other.

Red on the table, clear on the top, next to each other, and so on.

And if we have that, that's the main motivation for having propositions, propositions meaning things that are either true or false, that have internal structure.

That's the main thing. We have propositions with internal structures.

Just like we had states with internal structure, we now have propositions with internal structure.

And that gives us a lot of power. Very simple idea.

And gets you quite a long way.

You have to, you can explain in the language, in your modeling language, you can explain the wumpus in five or six sentences rather than thousands of propositional formulae.

You can talk about infinite things.

You can talk about the semantic web.

You can do jeopardy, which is classical AI topic, of course, and all kinds of things.

Context aware apps, and so on.

So you think about having an app that is context aware, that really has to be able to talk in a way about all the locations on the globe.

There are only finitely many, arguably, but still quite a lot.