[Haskell-beginners] Re: [Haskell-cafe] abou the Godel Numbering for untyped lambda calculus

DISCLAIMER: The last I studied this was over 20 years ago, so my brain is seriously rusty. You are warned...

you mean the godel function (denoted by # and generally will be in type, #:term -> number ?) is a kind of functions instead of a particular function?

No. The Godel mirror function (as defined by Godel) is a single function, the product of primes (whose ordering gives the position in the string) with exponents (giving the symbol at that position). However, I think any total injective function with partial injective inverse will do. Don't get hung up on the details of the mirroring (Godel doesn't). Once you accept that it can be done, there is no need to actually do it. There is nothing magic about integers, beyond the fact that elementary arithmetic is "well understood" by humans and should not have inconsistencies (it probably doesn't, but we can't prove it within any language more intuitive than arithmetic, so why should be believe the proof in that language?). Importantly, all but the last step of the proof can be encoded as primitive recursive functions, meaning that they always halt within a predetermined number of steps (satisfying the Finitists). Only the last step cannot be so limited. This is a clear example where non-finite mathematics has demonstrably more power in a fundamentally important way. Why bother going through this encoding? The main reason for the encoding is to overcome the fundamental limitation of structural induction whereby there is no "this" smaller than this. I.e. quoting a sentence only makes it longer. With functions on integers, this limitation is removed, so that although there is no string saying "This statement is not true", (since "This statement" != "\"This statement is not true\""), there *is* some function taking the Godel number of the unquoted This to the Godel number of the string to which it refers. Doing so takes some bit of cleverness, but the original proof in German is only about 8 pages long, as I recall. If we don't go with mirroring and just use strings, we need to introduce some equivalent trick, namely named functions. In a language without pointers and only lambda expressions, there is no way to refer to oneself without repeating the quote in infinite regression. For instance "\x -> 3333333" is longer than "333333". You cannot talk about a string without embedding it as a substring. However, once you add named functions to your metalanguage (Haskell): f 3 = 33333333 Then the string "f 3" is shorter than the string "xxxxxxx". Suppose f 4 = "~xxxxxxx". Now one can talk about the other with the shorter string on the left: length "f 3" < length "~xxxxxxx" but also length "f 4" < length "xxxxxxx". A longer string can talk about a shorter string (but not vice versa), so this mapping is critical to overcoming the limitation about talking about oneself. After that, the rest is easy: encode the Liar's Paradox and voila. once we have the encoding of a language, and construct functions to encode proof transformations, we can reduce derivability to a simple predicate derivable :: String -> Bool and look for some formula f such that derivable (f) == False and derivable("~" ++ f) == False. Godel's First Incompleteness Theorem merely says that there is some integer (which mirrors some well-formed formula) not in the set of integers that mirror "derivable theorems", making your system incomplete. Moreover, if you remedy this situation by adding this integer to the set as an axiom, you immediately can derive another integer which mirrors its negated formula, making your system inconsistent. The metasystem (with symbols for derivable, transformation rules like modus ponens, and the like), are not part of the formal system, but in the metalanguage. By encoding this metalanguage as well and redoing the above, you get Godel's Second Incompleteness Theorem, which says that no system can prove its own consistency, and if an axion is added to assert consistency, you can immediately also prove its negation, making it unsound. Don't look for a hat trick. Encoding the meta-meta-system buys you nothing extra. That's about all I can remember without hypnosis, and I'm afraid of what I might say under hypnosis... :) Dan Algebras Math wrote:

you mean the godel function (denoted by # and generally will be in type, #:term -> number ?) is a kind of functions instead of a particular function? If so, what kind of property this kinds of functions have? any limitation? how capable they will be?

Thanks

alg

On Tue, Mar 31, 2009 at 4:01 AM, Dan Weston mailto:westondan@imageworks.com> wrote:

I can't tell exactly what you're asking, but I'll give it a try! :)

primes :: [Integer] primes = [2,3,5,7,11,13,17,19,23,29,31,undefined]

godel :: String -> Integer godel = product . zipWith (^) primes . map (toInteger . ord)

-- Here is the identity function (note that double backslash is a single character godel "\\x -> x" 1629920514342441477851613634029704631135430980107335428017064836156091059806450516131002598452000651374890570022191128551421788559667251656959733380229796871976693176094558797489489057311763922507760911447493016261397754567695234219623056037447490713525815311253273691703346455275115486717580778238094808661626709709766328915159206002675716287759792707200037683200000000000000000000000000000000

-- = 2^92 * 3^120 * 5^32 * 7^45 * 11^62 * 13^32 * 17^120

ungodel :: Integer -> String -- ungodel . godel = id

(See http://en.wikipedia.org/wiki/Fundamental_theorem_of_arithmetic for why this works).

These numbers get large quickly, but are finite for any finite string of finite alphabet.

godel is a total function (every string has a unique integer), and its inverse (an exercise to the reader involving prime factor decomposition) would also be total if the alphabet were infinite (so that ord would be total).

Frankly, I wouldn't know how to begin encoding the godel numbering in the type system (shudder!), but being that it is a total primitive recursive function, I suppose there is no theoretical impediment.

In contrast, Godel's Theorems themselves cannot be so encoded because the last step involves a general recursive function.

Dan

Algebras Math wrote:

Hi all,

I am reading the book "The lambda calculus: Its syntax and Semantics" in the chapter about Godel Numbering but I am confused in some points.

We know for Church Numerals, we have Cn = \fx.f^n(x) for some n>=0, i.e. C0 = \fx.x and C1 = \fx.fx.

From the above definition, I could guess the purpose of this kind of encoding is trying to encode numeral via terms.

How about the Godel Numbering? From definition we know people say #M is the godel number of M and we also have [M] = C#M to enjoy the second fixed point theorem : for all F there exists X s.t. F[X] = X.

What the mapping function # is standing for? How could I use it? What the #M will be? How to make use of the Godel Numbering?

Thank you very much!

alg