Okay, so while this recompiles, are there any questions so far?

So we've been talking about graphs and trees and all of those kind of things as being important

data structures in symbolic AI.

One of the main things we've looked at is that we're using trees, which are special

graphs as data structures for well-bracketed languages.

And well-bracketed languages is something that's a staple in symbolic AI.

We've looked at 3x plus 4, which if you see it in the wild probably means something like

this.

But if you basically see something like this in the wild, this might be one of two things.

Anybody see what the two things are?

Yes.

You are assuming one of these things, which is c times the sum of x at 4.

Now c could be a function.

So the brackets might actually not be brackets, that kind of group, but which is c, you could

say apply to the sum of x plus 4.

You see the importance of brackets and all of those kind of things.

And in particular, there are even formalisms that use Unicode, basically MathML for instance,

or Unicode, that position an invisible character in here, an invisible times or an invisible

function application operator to disambiguate what you actually mean.

These invisible characters are things that don't take up any space, leave no mark, but

they're there as characters.

So whenever we're talking about languages, languages for representing the world, remember

objects.

That's one of the things that symbolic AI does.

Let me...

There we go.

And so brackets are something that's...

When we talk about languages, remember the languages might be things like constraint

satisfaction problems, or knowledge representation of the world, or HTML, which is a kind of

mildly symbolic language that basically tells you what things look like, but can do much

more if we're using techniques of the semantic web or something like this.

We need to reason and work with languages all the time.

And the thing we are going to use for that is trees, which are specific graphs, which

is why I'm talking about all of these things.

And here's a tribute to the fact that we're writing trees with the root on top, which

exists in very few places.

And we've basically started looking at the tool of choice, namely functional programming

languages and recursions, to do computation with trees.

That's really what any symbolic method in AI or outside AI, things like a compiler,

is also a symbolic method.

It takes a string, parses it into a tree, then does unspeakable things and brings out

another tree, a machine language tree, and then makes a string or a bit string out of

that, and that's something you can directly execute.

That's a typical thing.

It turns out, and I want to give you and talk through two examples here, that functional

programming is actually the method of choice for that.

You can do it in other programming, imperative programming languages as well, but functional

programming languages are much more direct, much easier to get correct.

So we think of trees, and we're going to go in a little bit more detail about these

things in a minute, as node-labeled trees.