So welcome everybody to the last lecture in LBS this semester, no, this year, there's

a difference.

And what we want to do today is to complete the Tableau machine, essentially for Fragment

4, there will be a little bit more leftover stuff to deal with the determiner the, which

has this uniqueness condition which we need to model at the logic side, so we have to

learn a little bit more logic, but the rest we can essentially directly do today.

And with that I would like to turn over to Frederick to kind of remind you of the setting.

Okay, so I'm going to do screen sharing.

All right, so what we've done on Tuesday is we've developed Fragment 4 under the semantics

construction so we made a small grammar.

I should probably rerun this, we can do more than that.

We made a logic, this propositional logic, just the same as we used to have.

And then we extended that with first order logic, that was the first really interesting

thing we did.

So we added a type for individuals as always and then we added the syntax for for all that

exists which means that we use this higher order abstract syntax trick that we did.

So the type of for all is we take a predicate and get a truth value, so the final proposition

and the idea behind it is that we say this predicate is true for everything.

That's always a bit confusing, but in a way it just means that we'll have a new syntax

that uses the lambda for the binder.

I'm trying to make a new cell.

I think I know what the problem is.

Yes, so we can just write now something like for all lambda x, feature of x implies runs

of x or something like that.

That would be our new syntax.

And then we made a situation theory, so to keep things a bit shorter we just said t is

teacher, d is dog, r is run, j is John and so on and we made the semantics construction.

So here the interesting thing happened, we changed what the noun phrase is.

We used to always have noun phrases of the type iota, noun phrases are individuals like

John and Mary and so on.

And now we use this sort of annoying type raising trick which means that the type of

noun phrase is much more complicated.

So it takes a predicate and gives us a proposition.

And the main idea behind that was that we say instead of taking the noun phrase and

giving it to the verb phrase as an argument, we do it the other way around.

We take the verb phrase and give it to the noun phrase and that allows us to have much

more complex noun phrases like every teacher and so on.

You wanted to say something?

Yes, this trick of type raising, right, replacing iota with iota to omicron to omicron is actually

something that happens quite a lot.

In the beginning it's a bit of a brain teaser, but in the end you'll see it again and again

and again.

And very often, and just keep it in mind, if you run into problems, often type raising

is the answer.

Because it gives you more flexibility.

In a way, the function space that we have for NP, which is basically predicates on predicates,

is much bigger than the space of just individuals.

And that is exactly what we're using.

With bigger of a function space, I mean, it just contains many, many, many more lambda

terms that we can play with.