There we go.

Share the screen.

Zoomies, can you see everything you need to see?

Just see again.

OK, can you hear me, zoomies?

I'll just take that as a yes and then we can go on.

So if I understand correctly, you finished up fragment three last week, doing a little

bit more of lambda calculus, which is kind of the main ingredient of talking about functions.

And we have the verb phrases howl, scream, scream, howl and scream are functions from

individuals in this case to truth values. And we used the beta reduction as a computation rule

to rearrange the stuff that basically comes in differently from the syntax than we want it in

the semantics. So the thing we want to keep in mind is that in the

syntax we want to have essentially and apply to howl

and scream to make a block. What was it? F4.

In another block. And in the logic we want to have things arranged differently.

We want to have howl of F4 and scream of F4.

We have to be able to copy and we kind of arrange things differently. And we do that

and that's really the bridge here is that and is just lambda p, lambda q, lambda x, px, qx.

I'd stick in those two into the p and the q and the f into the x and that would.

The other thing

you were talking about is the new fragment, fragment four, which has every a the.

And the idea there is that in the logic we introduce all exists.

And you talk about hyoid, abstract syntax where we can kind of do fiddling with the logic to

not quite have the pain of having to extend the language too much, but we just put some

more constants into the signature. Without having to do anything because one binder to rule them all,

the lambda is enough. And the last thing you really looked at was the iota.

And one thing I would like to briefly pick up upon is that the

if you look at a word like every or a or even that,

then you'll see that syntactically but also semantically those things really want two arguments.

Linguistic quantifiers and determiners always want two arguments. You give them every

dog and give them a first argument and that becomes an NP. And then you give them the second argument

runs and you can't kind of only give them one at least if you want to have a sentence.

The linguistic quantifiers are binary whereas logical quantifiers,

something like this, they're essentially unary.

Take one argument.

Yes, but in logic it's kind of if you have a run-of-the-mill logical quantifier it takes

one argument. And if we have something like first-order logic or high-order logic,

we can always do things like from x px implies qx. That would be kind of the binary morally,

but really

technically it's only one scope. And say we would have a logic without an

identification and without an implication. We just can't say what we want to say.

I think it's fine because we always have an implication, but there's just something I want you

to kind of be more aware of.

The same thing for all the existent even. In a way whereas

in linguistics we always have a non-trivial restriction. Every dog runs.

But the quantifiers in logic is everything runs. We're not restricting that. And if we want to,

we have to do certain tricks or introduce types.

Pipes are also as we say guarded. And very often that's interesting even logically these kind of

guarded logics have a much better behavior. They are much more likely to be decidable and so on.

If we have a logic that's not a logic, we can't say that it's a logic.