Okay, start the recording, share the screen.

Righto, so yes, zoom in so you can see the slides, right?

Okay, so we are looking at what we call track number three.

The big new thing is verb phrases here and things like verb phrase coordination.

Right, we looked at and, and or, and but, and those kind of coordinators between sentences before.

Take two sentences, could join them with an and, have a new sentence.

We're also doing it for verb phrases now.

That is syntactically relatively simple.

The complications we have in here and solved is the didn't, which we don't want to allow repeated application thoughts.

We kind of built a barrier between finite and non-finite based on the observation that it is,

So, this is, Ethel laughed, inflected, but Bertie didn't laugh, infinitive in this case, so non-inflected, and we've built that into the grammar, discussed that at a bit of length.

We didn't fix the scam yet.

We are going to do that in the next fragment.

The problem was, the problem for the translation was essentially that if we want, if we use predicates as the meaning of verb phrases,

Then we need the counterpart of the conjunction operator, the and and so on, to be a functional that works on functions.

In particular, something verb phrase meaning is, we can't use first of all logic functions for that because there's a finite signature in logic that we're presupposable.

We can now, in user space, make functions as we want.

Just providing how then screamed or something like that as a first of all logic function is not what we want.

We need a logic that can work with arbitrary order functions.

So, one of the things that I should possibly talk about to make things complete is the order of functions.

So, if we have a function like addition, plus, that takes two individuals, the numbers three and five, and gives me a number, that's what we call a first order function.

Those are the things that first order logic uses.

Those are the things that first order logic is not allowed to quantify.

Because things get difficult if you allow that.

Another example is, for instance, the predicate even takes an individual, a number, three for instance, and gives you a truth value.

Another thing that behaves like an individual in the sense that it doesn't take arguments.

So, functions are things that take arguments, and functions that take individuals, i.e. things that don't take arguments, as arguments, we call first order functions.

If a function takes a first order function as an argument, we call it a second order function.

The typical example in math would be the derivative function, which takes a function from reals to reals, and gives us a function from real to reals.

The derivative function, the integral function, there are quite a lot of second order functions. They are sometimes also called function models.

Other functions are evaluated at zero. Takes a function, gives us an individual, is also a high order function.

And now if something were to take these guys here as an argument and give you something else, that would be a third order function.

We have those things in programming as well. For instance, the match function.

Takes a function and a list, evaluates to the list f of a, b of c, a list f of a, f of b, f of c, is a second order function.

Folding a function over a list is a second order function. Those are the things that actually make things like big unions or sums or something like this, by folding union or sum or plus over a list or a set.

Second order functions are very nice for programming.

Third order functions exist, but most people cannot wrap their heads around it. I think sometimes we do third order programming, but definitely not fourth order programming.

I know three people who can do fourth order programming.

Other people say the same thing and it's usually the same three people that they know.

That's something that is really hard. It needs a lot of practice.

The thing is that if you do it, three people can read your code.

The others write it.

You could speak of 17th order programming, but really first and second order is usually what you need.

But we would like to have a target logic that can deal with all of this.

In this course, we're going to do second order relatively regularly.

We're going to do kind of spell out transformations that are in themselves third order, but we're not actually going to do that.

Okay, so we need something that can do with these things.

One of the main things there is looking at the types.

That's very useful to distinguish functions by type.

We're going to follow this idea by using arrow types.