SUMMARY of Go"del's and Turing's results:
------------------------------------------------------------------------------

Go"del defined

proves(P, N) :- parseForm(N),  /* ascii int N expands into the math formula Phi */
                parseProof(P), /* ascii int P expands into the proof Pi */
                "Phi is the last line of Pi".


Say that the above code has ascii int representation #888.  Then,

?- proves(P, 888).   /* asks if the provability formula itself has a proof */



notProvable(N) :- not(proves(P, N)).   /* math formula #N has no proof */

Say that the above code has ascii int representation #999.  Then,

?- notProvable(999).  
   /* asks if the not-provable formula has a proof that it is not provable!  */


If  notProvable(999)  is true, it means there is no proof of the formula 
                               (and therefore we can't prove this true fact)

If  notProvable(999)  is false, it means there is a proof that the formula is not provable,
    which is impossible (since the formula is false).     

Only the true case is possible:  notProvable(999)  is true precisely because there is no
proof of its truth!


Go"del's construction of  notProvable(999),  detailed in my notes, is more subtle:
Go"del had to show that the index number of  "notProvable(999)"  was *itself*  #999.
He accomplished this by hiding the inner 999 with an existential quantifier.


This is an overview of the First Incompleteness Theorem.  There is a Second Incompleteness
Theorem, which states that no formalization of set theory can ever be proved sound.
The consequence is that all of mathematics can never be proved trustworthy
(so all we can do is trust it).




Turing:

Like Go"del, he represented programs by their ascii codings.

Pretend we can write this analyzer program:

H(p) = returns 1, when program #p runs and halts
     = returns 0, when program #p runs and loops

If H is programmable, we can build this program:

E(p) = loops,     when H(p) returns 1
     = returns 1, when H(p) returns 0

So, we call  E(e),  where  #e  is the ascii index of program E :

    but  E(e)  loops exactly when it halts.

This is physically impossible.  Program  H  can never be built.




MORAL: A formal or physical system is incapable of answering all questions about *itself*.

       Regarding computing: General program analysis is impossible.