# The Halting Problem

Let's assume that it is possible to write a Python program that correctly tells whether other Python programs will eventually halt when given particular inputs. Let's call our hypothetical program halts. Here's a rough sketch of what it would look like:

```def halts(program, data):

... lots of complicated code ...

if ... some condition ...:
return True
else:
return False
```

Halts takes two inputs, called program and data. The first input is an arbitrary Python program, and the second input represents the data to feed to that program as input. Halts returns either True or False, depending on whether program ever halts when given data as input. For example, let's write a couple of simple Python programs to test halts with:

```def progA(input):
print 'done'

def progB(input):
if input == 1:
while True: pass   # this causes an infinite loop
else:
print 'done'
```

Now we can ask halts what these programs do when given various inputs. ProgA always halts, no matter what input we give it:

• halts(progA, 1) would return True
• halts(progA, 2) would return True

ProgB loops forever if we happen to feed it the value 1. Any other value will cause it to halt:

• halts(progB, 1) would return False
• halts(progB, 2) would return True

So far, we have every reason to believe that halts could exist, at least in principle, even though it might be a rather complicated program to write. At this point, Turing says "OH YEAH? If halts exists, then I can define the following program called turing which accepts any Python program as input..."

```def turing(program):
if halts(program, program):
while True: pass
else:
print 'done'
```

At this point, we say "Yes, so what?" Turing laughs and says "Well, what happens when I feed the turing program to itself?"

turing(turing)

What happens indeed? Let's analyze the situation:

• The turing program uses halts to analyze the Python program given to it as input:

• If the Python program halts when fed itself as input, then turing never halts.
• If the Python program never halts when fed itself as input, then turing prints 'done' and halts.

• But if the Python program happens to be the turing program itself, then:

• If turing halts when fed itself as input, then turing never halts.
• If turing never halts when fed itself as input, then turing prints 'done' and halts.

• This is a blatant logical contradiction!

• turing(turing) can neither halt nor loop forever; it doesn't make sense either way.

Thus our original assumption about the existence of halts must have been invalid, since as we just saw, it's easy to define the logically-impossible turing program if halts is available to us.

Q.E.D.

 Conclusion The task of deciding if an arbitrary computation willever terminate cannot be described computationally