Gui Ruiyan

Kurt Gödel · 库尔特·哥德尔
Gödel’s Incompleteness Theorems · 哥德尔不完备性定理

Study journals ·

Gödel's Incompleteness — Chapter II, Exercises 6–8: Base-10 Gödel Sentences, the Gödelizer, Cross-Reference

Reflections · Study sessions

AI-prepared recaps of study sessions; these are working notes, not verbatim transcripts. / AI 整理的学习记录,并非逐字实录。

Reading / 研读:Raymond Smullyan / 雷蒙德·斯穆里安 · Gödel’s Incompleteness Theorems 哥德尔不完备性定理

In this note / 篇目

Study session of July 23, 2026 · Smullyan, "Gödel's Incompleteness Theorems," Chapter II Exercises 6, 7, 8 (book p. 27) · Companion to the sessions of July 15, 17, 19, 20, 21, and 22, 2026 · Chapter II now complete in full


How to use this document

Exercise session: the machinery of July 22 — the wrapper, r, d, Lemma 1, the nine-step chain — run on three concrete assignments. No new theorems were learned; three new constructions were built out of owned parts, and each exercise contributed one idea worth keeping: Exercise 6 — a Gödel sentence can be false, and a well-chosen numbering lets a one-symbol glance at a string settle a property of an uncomputable number; Exercise 7 — the wrapper works with a variable in the slot, not just a numeral (and the session produced an original second architecture, debugged via the knobs table); Exercise 8 — cross-reference is manufactured from a pair of seeds wrapped identically into two formulas, and the whole design is governed by one accounting principle about how a specific number can reach a formula's text. For review: Part I's last-digit argument and the chains of Parts II, III, and IV are the content; the Ledger (Part VII) and Self-Test (Part VIII) are the refresher. A two-sided lesson about explanations — the second failure mode — is recorded in Part IX.

Scorecard, for honesty: Exercise 6 the user solved outright (the last-digit argument was his). Exercise 7 the user solved with an architecture different from the book's — initially buggy, repaired by him after the bug was located in his own July 22 knobs table. Exercise 8 was presented after burnout set in; the user's contribution was auditing the chain, which caught a genuinely missing justification (Part IV, Step 7).


Part I — Exercise 6: the base-10 numbering and the false Gödel sentence

The alternative numbering. Same 13 symbols, base 10 codes:

0   '   (   )   f   ,   v   ¬   ⊃    ∀     =      ≤       #
1   0   2   3   4   5   6   7   89   899   8999   89999   899999

The numeral ȳ (= 0 followed by y accents) now has code 1 followed by y zeros: 10ʸ (was 13ʸ). Concatenation ∗ is now base-10 gluing: x ∗ y = x·10^(number of digits of y) + y.

The construction, unchanged. A = the even numbers, Arithmetic via ∃v₂(v₁ = v₂ + v₂). Theorem 1's chain runs verbatim in the new numbering and hands us X = ∀v₁(v₁ = h̄ ⊃ H) with

g.n.(X) = r(h, h) = 899602608999 ∗ 10ʰ ∗ 89 ∗ h ∗ 3

(prefix "∀v₁(v₁ =" = digits 899 6 0 2 6 0 8999; then the numeral, ⊃, the block h, and ")").

The question and the lever. Theorem 1 guarantees the biconditional — X is true ⟺ g.n.(X) is even — but not which side holds. Nobody can compute g.n.(X): h is astronomical. But one feature of the string is visible without knowing h: X ends in the symbol ), so g.n.(X) ends in the digit 3. In base 10, the last digit fixes parity. So g.n.(X) is odd, hence not in A, hence — by the biconditional — X is false.

No contradiction, and the payoff of the whole exercise: a false Gödel sentence. The definition is a biconditional; false-X-with-code-outside-A satisfies it on the false side. This is the concrete answer to July 22's Self-Test question 1: a Gödel sentence need not be true.

Part 2, the odd numbers: same string shape, same last digit 3, same odd code — but now the guarantee reads "X true ⟺ g.n.(X) odd," so this X is true. Symmetry worth keeping: the evens' Gödel sentence is a false sentence asserting "my code is even"; the odds' is a true sentence asserting "my code is odd." Both correct about themselves in the only sense the definition demands.

What base 10 bought (and base 13 wouldn't). In base 13, N = Σ dᵢ·13ⁱ and 13 ≡ 1 (mod 2), so every term ≡ dᵢ (mod 2): parity of N = parity of the digit sum — the last digit alone says nothing; you would need all of h. In base 10, parity = last digit alone. Smullyan set the exercise in base 10 precisely so that a one-symbol glance at the string settles a property of a number nobody can write down.

Session repairs en route (all recurrences of known bugs): (i) the stars in the code formula are concatenation, not multiplication — multiplying by 3 doesn't make a number end in 3; (ii) "the Gödel number is ∀v₁(...)" — layer slip; the string is X, the number is the concatenation; (iii) the plugged-in object is the numeral h̄, not the number h.


Part II — Exercise 7: the Gödelizer, book architecture

The task. Find an Arithmetic f such that: if n is the Gödel number of a formula F(v₁), then f(n) is the Gödel number of a Gödel sentence for the set F(v₁) expresses. (On other n, f may output garbage.) Theorem 1 industrialized: not one Gödel sentence for one A, but one machine, uniform in n.

Notation, fixed at the door: Eₙ is the expression whose Gödel number is n (the §5 numbering names an expression for every number). The exercise's hypothesis on n says exactly that this expression is a formula with sole free variable v₁ — so Eₙ = F(v₁): two names for one string. "Eₙ" emphasizes how the proof reaches it (from the number n, as an unopened block); "F(v₁)" emphasizes its shape and job (expressing A). Every Eₙ below may be read as F(v₁).

Entry error, diagnosed first: F(v₁) was momentarily taken for a function with pairs (x, y). No — a formula with one free variable expresses a set of single numbers. The function-shaped thing is f itself, ℕ → ℕ, living in the metatheory like r and d; "f is Arithmetic" means some two-variable formula expresses its graph — and it gets certified by closure (built from Arithmetic pieces), never written by hand.

The reduction. Theorem 1's output address was d(h), h = g.n.(H). So the candidate is f(n) = d(h(n)), where h(n) = g.n. of the formula Hₙ that Lemma 1's recipe builds from Eₙ. d is Arithmetic and compositions of Arithmetic functions are Arithmetic, so the entire exercise reduces to: is n ↦ h(n) Arithmetic?

The trap (two illegal moves attempted in session):

  • "F(v₂), whose Gödel number is n" — no: n codes F(v₁). F(v₂) is a different string; producing its code from n requires interior digit-surgery (find occurrences of 60, check freeness, replace by 600, reassemble) — the sub ladder. If Hₙ contains the literal string F(v₂), the exercise re-buys Gödel's ladder.
  • "F(d(v₁))" — two crimes: d is not a symbol of L_E (a formula talks about the diagonal only through the graph formula D — the entire reason Proposition 2 exists), and F(anything) is literal substitution — opening the parcel.

The one new idea of the exercise: the wrapper takes a variable. Lemma 1's recipe calls for

∃v₂( D(v₁, v₂) ∧ F(v₂) )        ← defective: the conjunct F(v₂)

The defect: building the string F(v₂) from n means surgery inside Eₙ — dig out the v₁'s, insert v₂'s — the sub ladder. The repair is a drop-in replacement for that one conjunct, nothing more. Put the variable v₂ in the wrapper's slot:

Wₙ := ∀v₁(v₁ = v₂ ⊃ Eₙ)        ← the replacement part — not, by itself, the answer to anything

Wₙ's free variable is v₂ (the ∀v₁ binds every v₁, including Eₙ's, exactly as the numeral wrapper Eₙ[m̄] always has; the only novelty is a variable in the guard). Plugging m̄ into v₂ gives Eₙ[m̄], true ⟺ m ∈ A — so Wₙ says "F holds of v₂," exactly what F(v₂) said, but its string is a fixed prefix followed by Eₙ untouched: same meaning, no surgery. Now swap Wₙ into the defective slot, and this is the exercise's actual formula:

Hₙ := ∃v₂( D(v₁, v₂) ∧ Wₙ )  =  ∃v₂( D(v₁, v₂) ∧ ∀v₁(v₁ = v₂ ⊃ Eₙ) )

from which the chain below reads off h(n) = p ∗ n ∗ s and f(n) = d(h(n)). (That Wₙ alone cannot be the answer is visible at a glance: its free variable is v₂ and it expresses A itself — merely a restatement of F. Only inside Hₙ, with D pinning v₂ to the diagonal of v₁, does it earn its keep.)

The chain.

Given: n = the Gödel number of a formula F(v₁); A = the set F(v₁) expresses (so for all m: F(m̄) true ⟺ m ∈ A).

Step 1. Eₙ = F(v₁). (Justification: definition of the numbering — Eₙ is the expression whose Gödel number is n — plus the hypothesis on n, which says that expression is F(v₁). This identification is where n enters the construction, and it is the same move as Exercise 8's Step 7 run in the other direction: there a formula in hand was recognized as E_{h₁} because h₁ = g.n.(H₁); here the expression reached from n is recognized as the given formula.)

Step 2. Wₙ := ∀v₁(v₁ = v₂ ⊃ Eₙ). Free variable: v₂ — the ∀ captures every v₁ in its scope, wherever it sits (Step 1 guarantees Eₙ contains free v₁'s; none is ever located). For every m, plugging m̄ into v₂ yields literally ∀v₁(v₁ = m̄ ⊃ Eₙ) = Eₙ[m̄], and: Eₙ[m̄] true ⟺ F(m̄) true ⟺ m ∈ A. (Justification: grammar read off the string; then the equivalence; then Step 1 + the definition of expresses. Wₙ says "F holds of v₂" with Eₙ riding as one unopened block — F(v₂)'s job without F(v₂)'s string.)

Step 3. Hₙ := ∃v₂( D(v₁, v₂) ∧ Wₙ ). Free variable: v₁ — the v₁'s inside Wₙ are bound locally by Wₙ's own ∀; the same variable can be free in one part of a formula and bound in another. For every m: Hₙ(m̄) true ⟺ some value equals d(m) and satisfies Wₙ ⟺ d(m) ∈ A ⟺ m ∈ A. Hₙ expresses A. (Justification: Lemma 1's proof, with Step 2 supplying for Wₙ exactly what expressibility supplied for F(v₂) there. Uniform in n: no step so far opened Eₙ.)

Step 4. h(n) := g.n.(Hₙ) = p ∗ n ∗ s, where p and s are the fixed codes of the prefix "∃v₂( D(v₁, v₂) ∧ ∀v₁(v₁ = v₂ ⊃" and the suffix "))". h is Arithmetic. (Justification: the middle block's code is n — that is Step 1 again, read as numbers — and the string around it is constant; Corollary 1. Proposition 2's proof re-run with n in the parcel position that x occupied.)

Step 5. f(n) := d(h(n)) = r(h(n), h(n)). f is Arithmetic. (Justification: Proposition 2 (d Arithmetic) + Step 4 + closure of Arithmetic functions under composition.)

Step 6 — verification that f does the job. Let X := Hₙ[num(h(n))]. Then g.n.(X) = r(h(n), h(n)) = d(h(n)) = f(n) (definition of r at x = y = h(n), the wrapped expression being E_{h(n)} = Hₙ by Step 4 — the double-role identification once more). And: X true ⟺ Hₙ(num(h(n))) true (the equivalence) ⟺ h(n) ∈ A (Step 3 at m = h(n)) ⟺ d(h(n)) ∈ A (definition of A) ⟺ g.n.(X) ∈ A. So X is a Gödel sentence for A, and f(n) is its Gödel number. ∎ (This is Theorem 1's Steps 2–9 verbatim, with H := Hₙ, h := h(n).)


Part III — Exercise 7: the session's alternative architecture, and the knob repair

The user's proposal: instead of converting Eₙ to speak of v₂, bind Eₙ's native variable directly:

Hₙ := ∃v₁( D(v₂, v₁) ∧ Eₙ )

Eₙ's free v₁ is captured by the ∃v₁ and pinned to the diagonal of v₂ by the first conjunct. Eₙ unopened, no nested wrapper, h(n) = p ∗ n ∗ s as before. Semantically sound: Hₙ holds of m ⟺ (diagonal of m) ∈ A.

The bug, found by running the chain: Hₙ's free variable is now v₂, and the whole downstream kit is calibrated to v₁-formulas.

  • Step 3 jams (writing h for h(n)): X = ∀v₁(v₁ = h̄ ⊃ Hₙ) has no free v₁ to pin, and Hₙ's free v₂ sails through — X is not a sentence.
  • Obvious fix — wrap on v₂ instead: X = ∀v₂(v₂ = h̄ ⊃ Hₙ). Now X is a sentence, true ⟺ d(h) ∈ A. But its address is d′(h), where r′(x, y) := g.n.(∀v₂(v₂ = ȳ ⊃ Eₓ)) and d′(x) := r′(x, x) — a different diagonal. Truth condition names d(h), address is d′(h): the mismatch row of the July 22 knobs table. A cross-reference, not a Gödel sentence.

The repair (user's): make both knobs point at the same diagonal — put D′ inside, where D′ expresses d′. Entitlement is free: r′(x, y) = k′ ∗ 13ʸ ∗ 8 ∗ x ∗ 3 with k′ = code of "∀v₂(v₂ =" (digits 9 600 2 600 η) — Proposition 2's one-liner with a different constant.

The repaired chain: Hₙ := ∃v₁(D′(v₂, v₁) ∧ Eₙ); h(n) = p ∗ n ∗ s; X := ∀v₂(v₂ = num(h(n)) ⊃ Hₙ); g.n.(X) = r′(h(n), h(n)) = d′(h(n)); X true ⟺ Hₙ holds of h(n) (equivalence, v₂-version — same proof) ⟺ d′(h(n)) ∈ A, i.e. g.n.(X) ∈ A; f(n) = d′(h(n)). ∎

Verdict: two correct architectures, same price. The book's: one diagonal d, wrapper nested inside H. The session's: flat H, the whole kit (r′, d′, D′, equivalence) rebuilt on v₂. What the bug taught, again: what a formula says and what address a manufacturing method assigns are independent choices, and a Gödel sentence exists only where they match.


Part IV — Exercise 8: cross-reference — given, goal, chain

Given: A and B Arithmetic; F expresses A, G expresses B.

Goal: sentences X, Y with (i) X true ⟺ g.n.(Y) ∈ A, and (ii) Y true ⟺ g.n.(X) ∈ B.

Step 1. For expression Eₑ and numbers x, y define Eₑ[x̄, ȳ] := ∀v₁(v₁ = x̄ ⊃ ∀v₂(v₂ = ȳ ⊃ Eₑ)) and r₂(e, x, y) := its Gödel number. Off the string: r₂(e, x, y) = k ∗ 13ˣ ∗ 8 ∗ k′ ∗ 13ʸ ∗ 8 ∗ e ∗ 33. r₂ is Arithmetic. (Corollary 1 — Proposition 2's proof with more blocks.)

Step 2. t(x, y) := r₂(y, x, y) and s(x, y) := r₂(x, x, y) are Arithmetic. (Step 1 + repeating/rearranging argument slots — the move that made d(x) = r(x, x) Arithmetic from r.)

Step 3. Let T(v₁, v₂, v₃) express t's graph; H₁ := ∃v₃( T(v₁, v₂, v₃) ∧ F(v₃) ). For all x, y: H₁(x̄, ȳ) true ⟺ t(x, y) ∈ A. (Lemma 1's proof with t in place of d, pairs in place of single numbers. F is one fixed formula here — unlike Exercise 7, writing F(v₃) by hand once costs nothing; no uniformity in F is needed.)

Step 4. Likewise S expressing s's graph; H₂ := ∃v₃( S(v₁, v₂, v₃) ∧ G(v₃) ): for all x, y, H₂(x̄, ȳ) true ⟺ s(x, y) ∈ B.

Step 5. h₁ := g.n.(H₁), h₂ := g.n.(H₂). (Exist now: H₁, H₂ are finished strings built only from T, S, F, G — their texts mention no h.)

Step 6. X := H₁[h̄₁, h̄₂], Y := H₂[h̄₁, h̄₂]. (Merely written down; sentences, since the two ∀'s bind both variables.)

Step 7. g.n.(X) = r₂(h₁, h₁, h₂) = s(h₁, h₂); g.n.(Y) = r₂(h₂, h₁, h₂) = t(h₁, h₂). (Justification, fully unpacked — the session's audit found the compressed version missing a link: Step 1's definition applies to the string X only once X is recognized as Eₑ[x̄, ȳ] for particular e, x, y. The wrapped numerals are h̄₁, h̄₂ — read off Step 6's string. And the wrapped expression is H₁ = E_{h₁} precisely because Step 5 set h₁ = g.n.(H₁): "the expression whose Gödel number is h₁" is H₁ itself. Hence e = h₁ — and this identification, Step 5 feeding Step 7, is where h₁ acquires its double role: which-formula and wrapped-in value at once. This collision is what s(x, y) = r₂(x, x, y) encodes — the exercise's copy of d(h) = r(h, h).)

Step 8. X true ⟺ H₁(h̄₁, h̄₂) true. (The equivalence, applied twice — outer wrapper, then inner.)

Step 9. H₁(h̄₁, h̄₂) true ⟺ t(h₁, h₂) ∈ A. (Step 3 at (x, y) = (h₁, h₂).)

Step 10. t(h₁, h₂) = g.n.(Y). (Step 7.)

Step 11. Chaining 8–10: X true ⟺ g.n.(Y) ∈ A. Goal (i). ✓

Step 12. Y true ⟺ H₂(h̄₁, h̄₂) true (equivalence, twice) ⟺ s(h₁, h₂) ∈ B (Step 4 at (h₁, h₂)) ⟺ g.n.(X) ∈ B (Step 7). Goal (ii). ✓ ∎

Side-by-side with Theorem 1: Steps 1–2 play Proposition 2's role, Steps 3–4 Lemma 1's, Steps 5–6 are "let h = g.n.(H), let X = H[h̄]," Steps 7–12 are its Steps 4–8 run twice. The only structural novelty is Step 2: two functions read off one r₂ — t computes the other sentence's address (planted inside H₁), s computes this sentence's own (planted inside H₂). The crossing is installed in the formulas' texts, before any sentence exists.


Part V — Exercise 8 anatomy: the accounting principle and its consequences

How a specific number reaches a formula's text — two ways, one extension. (1) As a numeral written in — possible only if the number exists when the formula is written. (2) Through a free variable, delivered at wrapping time. Extension of both: once a formula has hold of n by either way, it can speak of f(n) for any Arithmetic f via f's graph formula — how H spoke of d(h) in Theorem 1 while only receiving h.

Two obstructions force the design. Spec (i) demands H₁ speak of g.n.(Y); a wrapped sentence's code is determined by which formula + which numbers wrapped in (that's all r₂'s closed form contains), so H₁ must receive h₂ and everything wrapped into Y. Could the h's be written-in numerals? (a) Mutual constants circle: h̄₂ inside H₁ requires H₂ finished first, and symmetrically — both, impossible. (b) Own code is barred outright: any string containing the numeral h̄₁ has code ≥ 13^(h₁) > h₁, so it cannot be H₁ — July 22 Part III's undershoot argument, reappearing. So the h's must arrive through free variables, at wrapping time — which is after both formulas are complete strings; that is what breaks the circle.

Bookkeeping → the symmetric design. L₁, L₂ = the numbers wrapped into X, Y. H₁ receives L₁ and needs h₂ and all of L₂; H₂ receives L₂ and needs h₁ and all of L₁. Simplest solution of both containments: L₁ = L₂ = (h₁, h₂) — the same pair into both. Two numbers to receive ⇒ two free variables ⇒ the two-variable wrapper.

Not the unique design. An asymmetric variant exists: write H₂ first, Theorem-1 style with no constants (∃v₂(D(v₁,v₂) ∧ G(v₂))); h₂ then exists, so hardcode h̄₂ into H₁ (which says "r(h₂, v₁) ∈ A"); wrap both sentences with the single number h₁: X = H₁[h̄₁], Y = H₂[h̄₁]. Works with one-variable machinery. The invariant across all solutions is the accounting principle, not the symmetric shape.

Theorem 1 as degenerate case. Set h₁ = h₂ and A = B and the construction collapses into Theorem 1: one seed, one diagonal (s and t coincide — the two-variable analogue of d), and the "other sentence" becomes the sentence itself.

Cross-reference is cheap. Recall July 22's diagnosis of H(h̄): a sentence about its sibling's address — Exercise 8's phenomenon appearing uninvited as a bug. Here it is engineered, symmetric, on purpose. What was ever impossible was not sentences pointing at each other, but self-reference applied to truth itself — Tarski.


Part VI — Concrete instance: A = evens, B = odds, base 10

X says "g.n.(Y) is even"; Y says "g.n.(X) is odd." Both strings end in ), so both codes end in digit 3: both odd. Therefore X asserts of an odd number that it is even — X false; Y asserts of an odd number that it is odd — Y true. Check the spec: X false and g.n.(Y) ∉ A ✓; Y true and g.n.(X) ∈ B ✓. Two sentences, each speaking only of the other, one wrong and one right, no paradox anywhere.


Part VII — Distinctions Ledger

Confusion raised One-line resolution
∗ read as multiplication ∗ is concatenation: x ∗ y = x·10^(digits of y) + y. Multiplying by 3 makes nothing end in 3; concatenating 3 does.
"The Gödel number is ∀v₁(v₁ = h̄ ⊃ H)" Layer slip: that string is X; its number is the concatenation; what X says (d(h) ∈ A) is a third thing.
"X is obviously false" (and stop) The owed sentence: check against Theorem 1 — X false with g.n.(X) ∉ A satisfies the biconditional. A Gödel sentence need not be true.
Would last-digit-3 settle parity in base 13? No: 13 ≡ 1 (mod 2), so parity = parity of digit sum — you'd need all of h. Base 10 makes parity a last-digit property; that is what the exercise's numbering bought.
F(v₁) taken for a function with pairs One free variable ⇒ expresses a set of single numbers. The function in Exercise 7 is f itself (metatheory, like r and d); its Arithmetic-ness comes by closure, never by hand.
"F(v₂), whose Gödel number is n" n codes F(v₁). F(v₂) is a different string; deriving its code from n is interior digit-surgery — the sub ladder. The variable wrapper ∀v₁(v₁ = v₂ ⊃ Eₙ) does F(v₂)'s job with Eₙ unopened.
"F(d(v₁))" Two crimes: d is not a symbol of L_E (graph formula D is how formulas mention the diagonal — Proposition 2's whole point), and F(...) opens F.
"Avoid the capture: define E_m := F(v₂) with its own code m, and build Hₙ from E_m" Legitimate string, fatal cost: h(n) = p ∗ m(n) ∗ s, and n ↦ m(n) — code of F(v₁) in, code of F(v₂) out — is the sub ladder. That's Gödel's route, price included. The wrapper's capture is deliberate and precedented (Eₙ[m̄] binds Eₙ's free v₁ the same way, since Theorem 1); it buys the same meaning with m(n) never needed.
"f(n) = X"; "H[h̄] is Arithmetic" f(n) is a number (= g.n.(X)); Arithmetic is a predicate of sets/relations/functions, and H[h̄] is a sentence. Both are July 22 ledger entries, recurring.
Flat Hₙ = ∃v₁(D(v₂,v₁) ∧ Eₙ) "just works" Its free variable is v₂; the v₁-calibrated wrapper leaves v₂ dangling (X not a sentence), and wrapping on v₂ instead mismatches the knobs (says d, lives at d′) — cross-reference. Repair: D′ expressing d′ = r′(x,x). Then a valid second architecture.
"Each sentence must contain the other's Gödel number" Neither can (mutual constants circle; own code barred by the 13^h undershoot). Each contains the pair of seeds (h₁, h₂), which exist before either sentence, plus a graph formula computing the other's address from the pair.
Why the same pair wrapped into both? Bookkeeping: H₁ needs h₂ and all of L₂; H₂ needs h₁ and all of L₁; L₁ = L₂ = (h₁, h₂) is the simplest solution. Two deliveries ⇒ two free variables ⇒ r₂.
Step 7 "read off the string" hides a link (User's catch.) e = h₁ needs Step 5: H₁ = E_{h₁} because h₁ = g.n.(H₁). That identification is the double role — the exercise's d(h) = r(h, h).
Why is H₁ built around t (the other's address function)? Spec (i) verbatim: X's truth condition must be "g.n.(Y) ∈ A" and g.n.(Y) = t(h₁, h₂). Swap in s and Step 9 becomes "⟺ s(h₁, h₂) ∈ A," which chained with Step 7 delivers "X true ⟺ g.n.(X) ∈ A" — a Gödel sentence for A, not cross-reference.
Doesn't mutual reference risk paradox? Run it concrete (evens/odds, base 10): X false, Y true, spec satisfied, no contradiction. Cross-reference is cheap; Tarski is self-reference on truth.

Part VIII — Self-Test

Answer before peeking.

  1. Exercise 6, full chain: why is the evens' Gödel sentence false, and why is that not a counterexample to Theorem 1?
  2. What exactly did the base-10 numbering buy that base 13 wouldn't? Prove the base-13 half.
  3. The variable wrapper ∀v₁(v₁ = v₂ ⊃ Eₙ): free variable, meaning, and the two illegal moves it replaces.
  4. State both Exercise 7 architectures. Where does the flat one jam if run against the v₁-calibrated kit, and what is the repair?
  5. Why is n ↦ h(n) Arithmetic in either architecture — and which July 22 proof is that argument a re-run of?
  6. Exercise 8: reproduce the twelve-step chain, citing for each step its justification.
  7. Unpack Step 7 completely. Where does e = h₁ come from, and what double role does that identification encode?
  8. The accounting principle: the two ways a specific number reaches a formula's text, the extension, and the two obstructions that bar the h's from being written-in numerals.
  9. Why the same pair (h₁, h₂) into both sentences? Derive it from the bookkeeping.
  10. Why does H₁ carry T (the graph of t) rather than S? What would you get instead if you swapped?
  11. Sketch the asymmetric variant. What does its existence tell you about which part of the construction is essential?
  12. In what precise sense is Theorem 1 the degenerate case of Exercise 8?
  13. Run A = evens, B = odds in base 10: truth values of X and Y, with the check against the spec.

Answers

  1. X = ∀v₁(v₁ = h̄ ⊃ H) ends in ), so g.n.(X) ends in digit 3, hence is odd, hence ∉ evens; by "X true ⟺ g.n.(X) even," X is false. No counterexample: the biconditional is satisfied on the false side — the definition never required truth.
  2. In base 10, parity = last digit (10 ≡ 0 mod 2). In base 13, N = Σ dᵢ·13ⁱ ≡ Σ dᵢ (mod 2) since 13 ≡ 1 (mod 2): parity = digit-sum parity, needing every digit of the astronomical code. Base 10 makes one visible symbol settle a property of an uncomputable number.
  3. Free variable v₂ (the ∀ captures every v₁ in its scope — the hypothesis Eₙ = F(v₁) guarantees free v₁'s exist without locating them); plugging m̄ into v₂ gives F(v₁)[m̄], so it says "F holds of v₂" while the code computation uses Eₙ only as an unopened block. Replaces: literal F(v₂) (whose code is not n; deriving it = sub ladder) and F(d(v₁)) (d is not a symbol of L_E; and F(...) opens F).
  4. Book: Hₙ = ∃v₂(D(v₁,v₂) ∧ ∀v₁(v₁ = v₂ ⊃ Eₙ)), free v₁, f(n) = d(h(n)). Flat: Hₙ = ∃v₁(D′(v₂,v₁) ∧ Eₙ), free v₂. Jam: ∀v₁-wrapper leaves v₂ free (not a sentence); wrapping on v₂ with plain D inside mismatches knobs (says d, lives at d′) — cross-reference. Repair: D′ expressing d′(x) = r′(x,x), r′(x,y) = k′ ∗ 13ʸ ∗ 8 ∗ x ∗ 3; then f(n) = d′(h(n)).
  5. In both, Hₙ = fixed prefix + Eₙ + fixed suffix as strings, so h(n) = p ∗ n ∗ s — concatenation of constants and the unopened block n: Corollary 1. A re-run of Proposition 2's proof with n in the parcel position x occupied.
  6. Part IV. Justifications: 1 Corollary 1; 2 slot rearrangement; 3–4 Lemma 1's method; 5 definition of g.n.; 6 written down; 7 definition of r₂ via Steps 5–6, then of s, t; 8 equivalence twice; 9 Step 3 at (h₁,h₂); 10 Step 7; 11 chaining 8–10; 12 mirror.
  7. r₂'s definition applies to X only once X is recognized as Eₑ[x̄,ȳ]: wrapped numerals (h̄₁, h̄₂) read off Step 6; wrapped expression is H₁ = E_{h₁} because Step 5 set h₁ = g.n.(H₁) — hence e = h₁. The identification gives h₁ two roles at once — which-formula and wrapped-in value — encoded by s(x,y) = r₂(x,x,y); the exercise's copy of d(h) = r(h,h).
  8. Ways: written-in numeral (number must pre-exist) or free variable (delivered at wrapping); extension: with n in hand, any Arithmetic f(n) is speakable via f's graph formula. Obstructions: mutual constants need each formula finished before the other; own code as numeral is impossible since a string containing h̄ has code ≥ 13ʰ > h. Hence the h's arrive by wrapping, after both formulas exist.
  9. H₁ receives L₁, needs h₂ ∪ L₂; H₂ receives L₂, needs h₁ ∪ L₁. L₁ = L₂ = (h₁, h₂) solves both containments minimally; two deliveries per formula ⇒ two free variables ⇒ the two-variable wrapper.
  10. Because spec (i) is "X true ⟺ g.n.(Y) ∈ A" and g.n.(Y) = t(h₁,h₂). With S instead, Step 9 becomes "⟺ s(h₁,h₂) ∈ A," and s(h₁,h₂) = g.n.(X) by Step 7 — so the chain yields "X true ⟺ g.n.(X) ∈ A": a Gödel sentence for A — self-reference where cross-reference was ordered.
  11. H₂ first, Theorem-1 style (no constants); h₂ exists, so hardcode h̄₂ into H₁ ("r(h₂, v₁) ∈ A"); wrap both with h₁ alone: X = H₁[h̄₁], Y = H₂[h̄₁]. Essential part: the accounting principle — enough must reach each formula to compute the other's address; the symmetric two-variable shape is just its cleanest solution.
  12. Set h₁ = h₂, A = B: the pair collapses to one seed, s and t coincide (playing d's role — a two-variable analogue, not literally r(x, x)), both sentences into one, and the chain becomes Theorem 1's nine steps.
  13. Both strings end in ) ⇒ both codes odd. X ("g.n.(Y) even") false; Y ("g.n.(X) odd") true. Spec: X false, g.n.(Y) ∉ A ✓; Y true, g.n.(X) ∈ B ✓. No paradox — cross-reference is cheap.

Part IX — Position, what's ahead, and the method

Position: Chapter II complete in full — text (§1–§6) and exercises (2–5 on July 20; 6–8 today). Every promise of Chapter I has been paid for the concrete language L_E, and today's exercises confirmed the machinery is usable, not just followable: run in a new numbering (Ex. 6), industrialized into a function (Ex. 7, two architectures), and re-plumbed into mutual reference (Ex. 8).

Next session: Chapter III — from truth to provability. "True" becomes "provable in a system," and two forward notes come due: the equivalence is provable, not merely true (July 22, Part VI(d)) — needed for the swap to survive; and the bridge theorem mechanical ⇒ Arithmetic (with P̃ still standing as the counterexample to its converse).

The debt register, unchanged: (1) Gödel's E-elimination. (2) Why prime base 13. (3) Property 1 ⇒ property 2. (4) Mechanical ⇒ Arithmetic — the provability chapters should start paying these down.

The method — the second failure mode of explanations. July 22 established that vivid coinages doing load-bearing work stall an explanation. Today found the failure on both sides of the July 22 fix and located the narrow channel between them. Exercise 8 was first presented as a compressed chain — too dense: "the steps don't connect, grammatically and semantically." The rewrite swung to natural-language paraphrase with fresh coinages ("preloading," "semi-diagonals," analogies) — rejected outright: "you don't need to replace symbolism with natural language — that's the last thing I want." What worked, on the third pass, was neither: symbols retained in full, the derivation of the design separated from the official proof, and every step of the official chain carrying its justification by explicit reference to a numbered step or an owned definition — the Theorem 1 Part V format, which the user requested by name. The channel is narrow: below it, links go invisible; beside it, invented vocabulary smuggles in unpaid debts. And the complementary reader's-side lesson: auditing justifications is not ceremony — the user's Step 7 audit ("this has one more justification: e = h₁, because of Step 5") caught the exact link where the diagonal trick lives. The step that "needs no theorem" is often the step carrying the construction's entire weight, and checking it is how you find that out.


End of session review · Smullyan, "Gödel's Incompleteness Theorems," Chapter II complete (text and Exercises 6–8) · Previous files: Godel-Incompleteness-Session-2026-07-15.md (Chapter 1 framework & machine puzzle), Godel-Incompleteness-Session-2026-07-17-Answer-Sheet.md (Chapter 1 exercises 1–7), Godel-Incompleteness-Session-2026-07-19.md (Chapter II §1–§2), Godel-Incompleteness-Session-2026-07-20.md (Chapter II §3, Exercises 2–5), Godel-Incompleteness-Session-2026-07-21.md (Chapter II §4–§5), Godel-Incompleteness-Session-2026-07-22.md (Chapter II §6, Theorem 1 & Tarski) · Next: Chapter III — provability.