
So far, all is good. But now I'm going to do the sneaky thing that I did in the last proof:

I'm going to put inverse halt into this list of programs. So if inverse halt is run on itself,

there can only be two cases, right? So, halt can either say yes or no.

We know it has to be one of the two cases, because there's no other possibility.

Now, just as above here, what would that mean? So if halt, on inverse halt and inverse halt, would say yes,

that would mean that inverse haltand I'm just going to write it like this, so inverse halt stops, given inverse halt as an input.

And the other case, of course, would mean that inverse halt does not stop, given itself as an input.

So this is what happens if we read the table in this way. Now, let's read it another way because what we noticed here is that,

if the program stops when it's given itself as an input, inverse halt on this program should go into an infinite loop.

In other words, if we transfer what we did here to down here, we would have to write the following.

So now let's compare those two statements in this line here. And here we said inverse halt will go into an infinite loop

when given inverse halt, which is just itself, as an input. So you have the same contradiction here as we had in the other proof.

And of course, the same thing is true down here. So here we said inverse halt does not stop, given itself as an input.

And here we said inverse halt does stop when given itself. So this table here is a nice way to introduce the kind of logic crash

that we use in the proof by contradiction. Because there's two ways of constructing this table.

So the first way is to construct it this way, basically. Meaning that we look at what halt sayseither yes or no

so we arrive at the conclusion of what the program does, based on what halt has to say about that program.

Now, the other way of constructing this table is more or less going this way.

So, based on what halt will say that the program does, we can predict the behavior of inverse halt.

And this construction works perfectly fine. So constructing it this way or this way, those are both compatible views.

With one exception: Once we feed inverse halt into this table, these two logics crash,

because the conclusions that we draw in this way are exactly the opposite of the conclusions that we draw in this way.

And that is why the contradiction is happening. And actually, constructing the table this way or this way is perfectly fine.

The only problem is making the assumption that this halt algorithm here actually exists,

which you already know it doesn't.