Gui Ruiyan

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

Study journals ·

Gödel's Incompleteness — Chapter III Opening: The Axiom System P.E., Interpretations, and the Adequacy/Incompleteness Divide

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 24, 2026 · Smullyan, "Gödel's Incompleteness Theorems," Chapter III §1 (book pp. 28–30) · Companion to the sessions of July 15, 17, 19, 20, 21, 22, and 23, 2026 · Chapter III begun: §1 conceptually consolidated; the chapter's formal work (§2 arithmetization onward) untouched · Second continuation of July 25, recorded as Part XI: the Group II–IV strings corrected against the book's page, the Discussion paragraph's substitution-avoidance claim unpacked, and the N₁₂ brackets recognized as the July 22 wrapper


How to use this document

Not an exercise session — a consolidation session, and the first one driven entirely by the reader's questions rather than the book's sequence. The opening pages of Chapter III display nineteen "axiom schemes," and the session began from an honest confession: these don't look like universally true axioms; they look like sentence structures one can judge about. That instinct turned out to be exactly right, and pulling on it unspooled the whole day: what an axiom is here (a chosen correct formula, not a self-evident truth) — in what sense correct (two different senses for two different groups) — what the material conditional ⊃ actually means (a table, not English "if–then") — what an interpretation is (the load-bearing term that had been used undefined) — what "first-order" means and what second-order grammar adds — and then the long excursus: why the 1930 adequacy theorem and the 1931 incompleteness theorem, despite their colliding names, not only don't contradict but compose, and why second-order logic can have no adequate machine at all. The excursus was won in stages, with several failed explanation attempts recorded in Part X, and ended with the session's structural discovery, made by the reader: the entire apparatus built to answer "why can't first-order compress?" is dispensable — Chain 1 (Dedekind), a six-step syllogism, and a four-line corollary satisfy the need, and the rest folds away into one line ("first-order lacks ∀P").

And then a post-session continuation un-dropped it, in improved form. The reader returned to "why is R not carved?", challenged an apparent circularity in the answer, and demanded the arrow directions of the whole argument. The resolution became Part VII: a single chain with a stated objective, two checkboxed verdicts, and every justification a citation — replacing the dropped scaffolding with something owned. Cross-references throughout this file are live links: every justification points at the rule, definition, theorem, or step it uses.

A second continuation followed on July 25, triggered by the reader holding this file against the book's own pages 29–30. It is recorded as Part XI: three misstatements in Parts I–II caught and corrected in place (marked), the book's claim that substitution — and even free/bound occurrences — are circumvented, unpacked (replacement vs substitution), and the square brackets of the induction scheme recognized — by the reader, before being told — as the July 22 wrapper returning for a harder job.

Everything here is aerial commentary: a second vantage point on the mountain the book climbs by a different route. Smullyan's Chapter III never mentions interpretations, survivors, or machines-as-printers; his proof is strings and diagonalization. Nothing in this file is a prerequisite for the book — but the axioms of P.E. can now be seen for what they are: the best a first-order system can do, chosen correct and shape-recognizable, with no pretense of pinning down ℕ.

Scorecard, for honesty. No book exercises were attempted. The reader's contributions: (i) before being told, identified the axiom schemes as templates rather than truths — the scheme/instance distinction, found independently; (ii) caught the term "interpretation" doing load-bearing work while undefined, and forced the glossary; (iii) produced his own account of the first-/second-order divide, graded piece by piece — core correct, two errors fixed; (iv) located the exact stalling joint of Chain 1's first draft (Steps 2→4→5), which exposed an unstated evaluation rule; (v) the consolidation itself — recognizing which parts of a week's scaffolding are load-bearing and which can be dropped; (vi) in the continuation, challenged the R-uncarved argument as circular — forcing the separation of the conditional theorem from the existence theorem — and proposed his own chain for grading, which exposed that adequacy had been misplaced as a conclusion when it is a premise; (vii) rejected a metaphor-laden anatomy paragraph ("credentials," "inflates," "the wall"), whose forced expansion caught a genuine error in the argument (see B18). Three owed answers are still outstanding (Part X). The July 25 continuation added three more contributions: (viii) caught this file misstating L₅, L₇, and N₁₂ by comparing it against the book's own page; (ix) recalled the July 22 wrapper unprompted ("we had our own version of substitution via a wrapper — what is different here?"), which became the organizing question of Part XI; (x) pressed a precise objection against the double-guarded string ("it still reads like v₁ = v₁′ — a contradiction?") whose resolution — the regions analysis — is the sharpest item in Part XI.


Part I — The Axiom System P.E.: what an axiom is

The system. P.E. = Peano Arithmetic with Exponentiation (standard PA has only + and ·; Smullyan adds E to smooth the Gödel argument, and later shows how to eliminate it). Axioms come in nineteen mechanically recognizable forms, in four groups: Group I (L₁–L₃, propositional logic), Group II (L₄–L₇, first-order logic with identity), Group III (N₁–N₁₁, eleven arithmetic axioms), Group IV (the induction scheme). Count: 3 + 4 + 11 + 1 = 19. Two inference rules: modus ponens (from F and F ⊃ G, get G) and generalization (from F, get ∀vᵢF). Provable = reachable from axioms by rules.

Scheme vs axiom — the session's first correction, made by the reader before it was taught. L₁ is displayed as (F ⊃ (G ⊃ F)). This is not a formula of the language: F and G are not symbols of P.E. It is a stencil at the level where we talk about formulas — the same metalanguage level where r, d, f lived in Chapter II. The axioms are the instances: plug in actual formulas (e.g. F := (0̄ = 0̄), G := (0̄ ≤ 0̄)) and a genuine axiom appears. Groups I, II, IV are stencils with infinitely many instances each; Group III's odd title ("schemes having only one axiom apiece") means N₁–N₁₁ are ordinary single formulas — stencils with nothing to fill.

"Correct" in what sense. Exactly the Chapter II sense, nothing more mystical: a sentence is correct iff true in the intended interpretation; a formula with free variables is correct iff true for every value of them. So (v₁ + 0̄) = v₁ is correct because 0+0=0, 1+0=1, 2+0=2, … — end of story. "Axiom" here means "designated correct starting formula," chosen under three constraints: (a) correct — else the engine generates falsehoods; (b) recognizable by shape alone — a dumb procedure can check axiomhood, which is what §II's arithmetization will feed on; (c) strong enough for the chapter's purpose. The choice is a toolkit, not a discovery — Smullyan credits Groups I–II to Kalish–Montague 1965; other books choose different equivalent lists.

Two senses of correct, for two kinds of group. Every instance of Groups I–II is true in every interpretation whatsoever — true by the meaning of ⊃, ∼, ∀, = alone, subject matter irrelevant ("valid"). Groups III–IV are true of ℕ specifically and can fail elsewhere: on a twelve-hour clock, ∼(0̄ = v₁′) is false (11′ = 0). Each arithmetic axiom is a filter that disqualifies rival interpretations.

The ladder (Dedekind–Peano). The idea behind the arithmetic axioms: ℕ is a ladder — a bottom rung 0; every rung has a unique next (′); 0 is nobody's next; different rungs have different nexts; and induction — anything holding at 0 and climbing holds everywhere (no side-branches, no unreachable rungs). Then +, ·, E, ≤ are not extra assumptions but recursion recipes riding on the ladder: n + 0 = n and n + m′ = (n + m)′ pin down every addition fact. Worked in session:

3 + 2 = 3 + 0′′ = (3 + 0′)′ = ((3 + 0)′)′ = ((3)′)′ = 5

— each equality by one of the two addition axioms. Multiplication is repeated addition (n·0 = 0, n·m′ = n·m + n), E is repeated multiplication (n E 0 = 1, n E m′ = (n E m)·n), and ≤ is characterized stepwise (n ≤ 0 iff n = 0; n ≤ m′ iff n ≤ m or n = m′; any two numbers comparable). Group IV is the domino principle, one instance per formula F(v₁):

N₁₂ : (F[0̄] ⊃ (∀v₁(F(v₁) ⊃ F[v₁′]) ⊃ ∀v₁ F(v₁)))

[Corrected July 25 — an earlier draft of this file displayed the scheme with literal substitution, F(0̄) and F(v₁′). The book's axiom uses the bracketed F[0̄] and F[v₁′] — the July 22 wrapper — precisely so that F rides unopened; the substitution version is the equivalent the brackets are proved to match, not the axiom. See Part XI.]

Engine vs subject matter. Groups I–II are a subject-neutral reasoning engine (they'd be identical in a formalization of geometry); Groups III–IV are the arithmetic seed. The rules preserve correctness, so everything provable is correct (soundness). The theorem the chapter drives toward is the converse failing: some correct sentence is unprovable. The magic is not in the axioms; it is in the gap between what they generate and what is true.


Part II — The material conditional, and the meanings of L₁–L₇

The table, and why it is forced. F ⊃ G is defined by: false when F true and G false; true in the other three cases. This is not a claim about English — it is the price of making "for every n: F(n) ⊃ G(n)" mean "there is no counterexample." Check "if n is divisible by 4 then n is even" at n = 8 (T,T), n = 6 (F,T), n = 3 (F,F): none of these should break the universal claim; only a divisible-by-4 odd number (T,F) would. So rows 1, 3, 4 must count as true. Consequences the reader resisted, rightly, as clashing with everyday "if–then": whenever the consequent is true, the conditional is true; whenever the antecedent is false, the conditional is true ("if 1 = 0 then 0 = 0" is true). The clash is famous — the paradoxes of material implication — and does not go away; ⊃ deliberately drops the English connection-requirement and keeps only truth-value bookkeeping, because bookkeeping is what a machine can check.

The logical schemes, each with its job:

  • L₁ : (F ⊃ (G ⊃ F)) — "a truth is implied by anything." Verified by two cases: F true → G ⊃ F has a true consequent, so true, so the whole is T⊃T; F false → false antecedent, true outright. Every instance true regardless of what F, G mean: a tautology.
  • L₂ : ((F ⊃ (G ⊃ H)) ⊃ ((F ⊃ G) ⊃ (F ⊃ H))) — distribution: modus ponens under a standing assumption. If from F you can get G ⊃ H, and from F you can get G, then from F you can get H. What lets the engine chain steps inside "suppose F…".
  • L₃ : ((∼F ⊃ ∼G) ⊃ (G ⊃ F)) — contraposition: teaches the engine how ∼ interacts with ⊃; ancestor of proof by contradiction. [Case-check still owed by the reader — Part X.]
  • These three plus modus ponens generate all tautologies (propositional adequacy — accepted, not proved).
  • L₄ : (∀vᵢ(F ⊃ G) ⊃ (∀vᵢF ⊃ ∀vᵢG)) — ∀ distributes over ⊃.
  • L₅ : (F ⊃ ∀vᵢF), provided vᵢ does not occur in F — vacuous quantification adds nothing. The side condition is essential: without it, (v₁ = 0̄ ⊃ ∀v₁(v₁ = 0̄)) would be an axiom — and it is false at v₁ = 0. [Corrected July 25 — an earlier draft said "not free in F." The book's condition is "does not occur at all," and the strengthening is deliberate: occurrence is a bare symbol-scan, freeness needs scope-parsing, and avoiding the latter is the system's design theme — Part XI.]
  • L₆ : ∃vᵢ(vᵢ = t), provided vᵢ not in t — every term has a value. Side condition blocks ∃v₁(v₁ = v₁′).
  • L₇ : (vᵢ = t ⊃ (X₁vᵢX₂ ⊃ X₁tX₂)), where X₁vᵢX₂ is an atomic formula (replacement of equals): if the variable vᵢ equals the term t, replacing one occurrence of vᵢ by t inside an atomic formula preserves truth — what makes = mean identity. Instance: (v₁ = 0̄′ ⊃ (v₁ ≤ 0̄′′ ⊃ 0̄′ ≤ 0̄′′)). [Corrected July 25 — an earlier draft wrote "if t₁ = t₂, swapping them inside an atomic statement," which is the derivable general form, not the axiom; the variable-not-term, one-occurrence, and atomic restrictions are each load-bearing — Part XI.]

Part III — Interpretations, and the two orders of logic

Interpretation — the term that had been undefined. A formula by itself is ink. An interpretation assigns: (1) a domain D — what ∀v₁ ranges over; (2) which object 0̄ names; (3) what ′, +, ·, E do to objects and when ≤ holds. Only then does every sentence become true or false. The intended interpretation: domain 0, 1, 2, …, symbols standard; correct (all of Ch. II) = true here. Rivals evaluated in session: the twelve-hour clock (passes (v₁ + 0̄) = v₁, fails ∼(0̄ = v₁′) since 11′ = 0) and the one-object world (even 0̄ = 0̄′ comes out true). Valid = true in every interpretation (Groups I–II). Logical consequence of given axioms = true in every interpretation that passes them.

Orders = what the quantifiers range over. Zeroth order: no quantifiers (propositional). First order: quantify over the domain's objects. ∀v₁((v₁ + 0̄) = v₁) covers all numbers — first-order universality over objects is total. Second order: additionally quantify over properties (= subsets of the domain): new variables P, Q; new atomic shape P(v₁); quantifier ∀P. The one thing first-order grammar cannot say is "for every property" — and that is where induction bites: Peano's own induction postulate is naturally second-order ("for every property: …"), and P.E. must fake it with a scheme, one axiom per formula-expressible property. The substitution is quietly lossy: formulas are listable (finite strings, finite alphabet — the Ch. II listing), sets of numbers are not (the Ch. II diagonal), so the scheme covers a countable slice of an uncountable totality of properties.

Corrected error (the reader's own formulation, graded): first-order logic does not fail to "cover all natural numbers" — it covers all numbers and cannot cover all properties. The entire divide between the orders is that one grammar clause.


Part IV — Adequacy vs incompleteness: the glossary and the three theorems

The names "completeness theorem" (1930) and "incompleteness theorem" (1931) collide by historical bad luck; the session renamed the first adequacy and kept "complete" for whole systems. The glossary, as fixed:

  • Machine — a finite instruction list that mechanically emits ("prints") strings forever, by shape-checking alone. Every proof system determines one (print the axioms, apply the rules to what's printed). Prove = print. Mechanical = runnable by such a finite instruction list — no oracle, no infinite lookup.
  • T — the set of sentences true in the intended interpretation.
  • Passes / survivor — an interpretation passes axioms if it makes them all true.
  • Copy of ℕ — ℕ with objects renamed; makes exactly the same sentences true.
  • Impostor — a survivor that is not a copy of ℕ.
  • Sound (for a target set) — prints nothing outside the target.
  • Adequate — the engine prints every logical consequence of whatever axioms it is fed: print-set = consequence-set, exactly.
  • Duty (of the engine, fed a stock of axioms) — the consequence-set itself: the sentences true in every survivor of that stock. So "adequate" = print list coincides with duty.
  • Complete / incomplete (for a sound system) — prints all of T / misses some truth.
  • Categorical — axioms whose only survivors are copies of one single world.

The three theorems, one line each:

  • Dedekind 1888: the second-order Peano axioms are categorical. (A theorem about interpretations only — proof, machines, printing do not occur in it; those concepts didn't exist yet.)
  • Gödel 1930 (adequacy): an adequate engine exists for first-order logic — Groups I–II plus the two rules. Whatever logically follows from your axioms, the machine prints; adding more valid logical axioms shortens proofs but never yields a new theorem. (For logic, the toolkit is provably finished — the answer to "are these 19 the only schemes?": the logical ones provably suffice; the arithmetic ones provably never can.)
  • Gödel 1931 (incompleteness): no machine sound for T prints all of T. Equivalently, in the form Part VII uses (the machine limit): no mechanical machine prints exactly T — printing exactly T would be soundness plus completeness at once. (The book's theorem; Chapter III proves it for the specific system P.E., and the fully general machine form is earned in the later abstract chapters — same construction, widening radius.)

Why no contradiction — the see-saw. The engine's obligation is fixed by definition: print everything true in all survivors of the axioms — the duty. The duty's size therefore depends on the survivor pool: many survivors → few sentences true in all → small duty; few survivors → large duty. First-order axioms cannot drain the pool to copies of ℕ (B6 proves this outright), so the duty sits strictly below T — and the 1930 theorem shows that smaller duty is exactly machine-doable. The leak is not a bug adequacy overcomes; the leak is why the finish is reachable. Second-order axioms drain the pool to copies of ℕ (Dedekind = Chain 1), the duty inflates to all of T, and 1931 forbids any machine from covering it. Hence: the first-order engine is complete because its language is too weak to ask for the impossible; strong language or strong engine — never both. The deficiency of P.E. is never the engine's: unprovable truths are unprovable because they do not logically follow from the axioms — each is false in some surviving impostor.

Three ledgers, kept apart (a distinction won in the continuation): the survivor pool is a set of worlds; the duty and the print list are sets of sentences. "Impostors survive" is a pool-fact; "provables sit below truths" is a print-list-fact; adequacy is the weld making print list = duty. And only a loud impostor — one that disagrees with ℕ about some sentence — shrinks the duty; a quiet impostor (not a copy, yet agreeing with ℕ on every sentence) shrinks nothing. The arrow runs from the print-gap to the loud impostor (the four-line corollary), never backward.

Two attributions corrected in session: Dedekind did not prove "every truth is provable" (his theorem has no proof-concept in it); and 1930 does not say "all machines are adequate" (almost none are — it says at least one adequate engine exists, for first-order).


Part V — Chain 1: the second-order sentence A pins down ℕ (Dedekind)

The session's one fully-owned formal result, in the July 23 format: evaluation rules and definitions stated first as citable items, every string parsed before use, every step justified by name. The chain's first draft stalled at the reader's exact question — how does Step 2 lead to Step 4, and does Ind's content matter? — which exposed an unstated rule (R3, the instance rule). Stated, the stall dissolved.

Evaluation rules. A world M = (D, z, s): domain D, object z named by 0̄, operation s meant by ′.

  • R1 (dictionary): 0̄ → z; t′ → s(t's value); t₁ = t₂ asserts sameness of objects; ∼, ∧, ⊃ by their tables.
  • R2 (∀ over objects): ∀v₁φ true in M ⟺ for every object x of D, the instance at x (φ with v₁ read as x) is true. Uses: (i) one false instance falsifies the universal; (ii) a true universal may be cashed out at any chosen instance.
  • R3 (∀ over properties): ∀Pφ true in M ⟺ for every subset S of D, the instance at S (φ with P(t) read as "t's value ∈ S") is true. R2 with subsets replacing objects as the index set; same two uses.
  • R4 (the ⊃ row): true conditional + true antecedent ⇒ true consequent.

Definitions.

  • D1 (passes/survivor), D2 (copy of ℕ), D3 (impostor) — as in Part IV.
  • D4 (compresses): an axiom stock compresses ℕ if it is a single finite sentence whose survivors are exactly the copies of ℕ. (Extended in Part VII to infinite lists.)
  • D5 (reachable part, junk/aliens): in (D, z, s): R := {z, s(z), s(s(z)), …} — the objects reached from z in finitely many s-steps. Objects outside R are junk, called aliens in Part VII. R is defined by us, in the metatheory — like r, d, f of July 22–23, it exists whether or not any formula describes it.

The strings, parsed.

S1 := ∀v₁ ∼(v₁′ = 0̄)                 — in M: "z is nobody's successor"          (R1, R2)
S2 := ∀v₁∀v₂(v₁′ = v₂′ ⊃ v₁ = v₂)     — in M: "different objects, different successors"
Ind := ∀P( (P(0̄) ∧ ∀v₁(P(v₁) ⊃ P(v₁′))) ⊃ ∀v₁ P(v₁) )
A := S1 ∧ S2 ∧ Ind                     — one finite string

Parse of Ind via R3 — the instances are indexed by subsets S of D:

Instance(S):  "if z ∈ S and S climbs (x ∈ S ⇒ s(x) ∈ S, all x ∈ D), then every object of D is in S"
Ind in M:     "for every subset S of D: Instance(S)"

First-order substitute — the scheme, one sentence per formula F(v₁):

Ind_F := (F(0̄) ∧ ∀v₁(F(v₁) ⊃ F(v₁′))) ⊃ ∀v₁ F(v₁)

Parse: with the carved set C_F := {x ∈ D : F is true of x in M} — set-builder notation: the set of all x in D such that F holds of x, a membership test, not an assertion; it is Chapter II's "the set F expresses," relativized from ℕ to the world M on trial — Ind_F in M says exactly Instance(C_F). So the scheme guarantees the conditional only at carved sets (one per formula, listably many); Ind guarantees it at every subset. C_F depends on both F and M: (v₁ = v₁) carves D, ∼(v₁ = v₁) carves ∅, and the Ch. II evenness formula carves the evens in ℕ. "R is carved in M" means: some formula F has C_F = R — coinciding exactly, not merely ⊆ or ⊇.

Chain 1. Given: the sentence A. Goal: every survivor of A is a copy of ℕ (D4).

Step 1. Let M = (D, z, s) survive A: S1, S2, Ind each true in M. (D1.)

Step 2. For every subset S of D, Instance(S) is true in M. (R3 applied to Ind's parse — this unpacking is all that "Ind true in M" means.)

Step 3. Let R := {z, s(z), s(s(z)), …}. (D5; metatheoretic — no formula describes R and none is needed.)

Step 4. R is a subset of D. (Step 3 — members produced by s inside D. The entry ticket: Step 2's guarantee is indexed by subsets, and subsethood is the sole qualification; describability appears nowhere.)

Step 5. z ∈ R. (Step 3 — reachable in zero steps.)

Step 6. R climbs. (Step 3 — one more s preserves reachability.)

Step 7. Instance(R) is true in M. (Step 2 cashed out at S := R, licensed by Step 4 — direction (ii) of R3. The sole step where second-order grammar acts.)

Step 8. Instance(R)'s antecedent is true: z ∈ R and R climbs. (Steps 5, 6 — facts about R from its definition; the axiom contributed nothing to them.)

Step 9. Instance(R)'s consequent is true: every object of D is in R — M has no junk. (R4 on Steps 7, 8 — modus ponens at the semantic level.)

Step 10. The map 0 ↦ z, 1 ↦ s(z), 2 ↦ s(s(z)), … is onto D. (Step 9 with Step 3.)

Step 11. The map is one-to-one. (If sⁿ(z) = sᵐ(z), n < m: peel n times with S2 to get z = s^(m−n)(z), making z a successor — contradicting S1. Both true in M by Step 1.)

Step 12. M is ℕ renamed — a copy; M was arbitrary: A compresses ℕ. ∎ (Steps 10–11; D2, D4.)

The mechanics run backward — how Ind convicts. In the alien world M (domain = 0, 1, 2, … plus a two-way ladder of aliens …a₋₁, a₀, a₁…, never touching the numbers): S1, S2 hold (no loops, no merges — the successor axioms cannot see junk). But R = the numbers only; Instance(R) has true antecedent, false consequent (aliens ∉ R) — false; one false instance falsifies Ind (R3, direction (i)); M fails A. Same string, same table: in a survivor it forces junklessness; in a junk world it detects the junk by borrowing the world's own reachable part as evidence. The first-order scheme cannot make the kill: its guaranteed conditionals sit only at carved sets, and nothing guarantees R is carved — an observation upgraded in Part VII to a theorem: in any alien survivor of the first-order list, no formula carves R (B13).


Part VI — The syllogism, the corollary, and the consolidation

The six-step syllogism (no adequate machine for second-order logic):

  1. Definition: consequence of axioms = true in all survivors (= the duty).
  2. Dedekind (= Chain 1): survivors of the second-order Peano axioms = copies of ℕ only.
  3. 1 + 2: consequence of those axioms = true in all copies of ℕ = true in ℕ = T. (Copies make the same sentences true — D2; the consequence-set and T are literally the same set.)
  4. Definition of adequate: an adequate second-order machine, fed the Peano axioms, would print exactly their consequences — by 3, exactly T: all truths, no falsehoods.
  5. Gödel 1931: no machine does that.
  6. Therefore no adequate machine for second-order logic exists. ∎

Every step is a definition, Chain 1, or 1931. (The concrete mechanism behind step 3, from the session: the finitely many second-order Peano axioms conjoin into one sentence A, and for any arithmetic S, "(A ⊃ S) is valid ⟺ S ∈ T" — every arithmetic question folded, one by one, into a validity question about a finite string.)

The four-line impostor corollary — replacing the heavier machinery. Given: G true in ℕ, unprovable in P.E. (Gödel 1931 — the book's own theorem). Goal: P.E. has an impostor survivor.

  1. Provable from P.E.'s axioms = true in all their survivors. (Adequacy 1930 — the standing debt.)
  2. G unprovable ⇒ G not true in all survivors ⇒ some survivor M makes G false. (Step 1, contraposed.)
  3. ℕ is a survivor (the axioms are correct) and G is true in ℕ.
  4. M and ℕ disagree about G, so M is no copy (D2): M is an impostor — a loud one. ∎

Attribution kept straight: impostors are a corollary of the first incompleteness theorem (via adequacy), not its content — the book's work is strings and diagonalization; interpretations never appear in it.

The consolidation — the reader's structural discovery, then the rebuild. A further apparatus was built in session to answer "why can't first-order compress, essentially?" — a diagnosis chain (where Chain 1's proof jams for the scheme) and an exhaustion chain (via a new constant c and compactness). The reader recognized that none of it was load-bearing as built: the syllogism needs only Chain 1, the definitions, and 1931; impostor-existence follows from the four-line corollary; and the essence question closes with one line — first-order lacks ∀P. The apparatus was dropped. In the post-session continuation, however, the reader's own questions — why exactly is R not carved? isn't assuming R ≠ D circular? — pulled the dropped material back, and it was rebuilt as Part VII: one chain, compactness-free, with the arrow directions audited. The final ledger:

Claim Status
A's survivors = copies of ℕ Proved outright — Chain 1, no debts
No adequate machine for second-order logic Six-step syllogism, given 1931
First-order arithmetic incomplete; impostors exist The book's theorem + four-line corollary; debt: adequacy 1930
First-order Σ does not compress ℕ; in its impostors R is uncarved Proved — Part VII, ☑ G1 + ☑ G2; debts: adequacy 1930, machine limit, operation-agreement
Why first-order can't compress (essence) "Lacks ∀P" — now with the mechanism visible: the guarantee's index set changed from subsets to carved sets, and the sets that would convict are exactly the ones no alien world lets any formula carve (B19)

Part VII — The rebuilt chain: first-order Σ does not compress ℕ

Post-session continuation, same day. Triggered by the reader's "why is R not carved?" and his circularity challenge; his own proposed chain was graded (adequacy found misplaced as a conclusion — it is a premise), and the corrected version below entered the see-saw from the opposite end to Part VI: the syllogism holds compression fixed (Chain 1) and concludes adequacy must give; this chain holds adequacy fixed (the 1930 theorem) and concludes compression must give. One see-saw, entered from both ends. Compactness appears nowhere.

Objective.

  • G1: some world passes every sentence of Σ yet is not a copy of ℕ — Σ does not compress ℕ.
  • G2: in that world, no formula carves R — which is exactly how it passes every induction axiom while keeping its aliens.

The chain ends when both verdicts are announced; the steps after them are anatomy.

Terms. Part IV–V's items are in force: machine, duty, adequate, T, survivor (D1), copy (D2), impostor (D3), carve / C_F, Instance(S), and the parse "Ind_F in M says exactly Instance(C_F)" — all quoted from Part V and used verbatim. New:

  • Σ := the first-order axiom list — S1, S2, the arithmetic axioms, and every instance Ind_F. Induction is a scheme, so the candidate compressor is an infinite list, not one sentence; D4 extends: Σ compresses ℕ iff every survivor of all of Σ is a copy of ℕ.
  • Alien := D5's junk: a member of D outside the reached part R — an object no numeral names; counting up from z by s-steps never lands on it.

Given. (i) the adequacy theorem — first-order logic has an adequate machine, print list = duty; (ii) the machine limit — no mechanical machine prints exactly T. Both aerial, on the debt register (items 5 and 6).

The chain.

B1. Load the adequate machine with Σ. Its print list = duty(Σ) = the set of sentences true in every survivor of Σ. (Given i; duty.)

B2. Suppose Σ compresses ℕ: every survivor of Σ is a copy of ℕ. (Assumption to refute; Σ.)

B3. ℕ itself is a survivor of Σ — every axiom on the list is correct, i.e. true of ℕ. (Part I; D1.)

B4. Then duty(Σ) = T. One direction: a sentence true of ℕ is true in every copy (D2), hence in every survivor (B2), so it is in the duty. Other direction: a sentence in the duty is true in every survivor, in particular in ℕ (B3), so it is in T. (B2, B3.)

B5. So the machine's print list is exactly T. (B1, B4.)

B6. A mechanical machine printing exactly T contradicts the machine limit. So B2's assumption fails: ☑ Verdict G1 — Σ does not compress ℕ. Fix a survivor M = (D, z, s, …) that is not a copy: an impostor. (Given ii; D3.)

B7. Note what did not break: the machine still prints exactly its duty — the contradiction executed the assumption, not the adequacy. Impostors and adequacy coexist; M's survival simply holds duty(Σ) strictly below T. (B6; the see-saw.)

B8. M has aliens. For if R = D — every object of M reached — M would be a copy of ℕ: the numerals name distinct objects forming a successor chain (S1, S2 — the argument of Chain 1's Steps 10–11), and the arithmetic axioms pin +, ·, E, ≤ to ℕ's tables on named objects (operation-agreement: aerial, debt 7). A copy contradicts B6. So R ≠ D. (B6; D5.)

B9. Toward G2: suppose some formula F carves R — C_F = R. (Assumption to refute; carve.)

B10. Ind_F is on the list Σ and M survives Σ, so Ind_F is true in M; and Ind_F in M says exactly Instance(C_F) — by B9, Instance(R). (D1; the parse, quoted from Part V.)

B11. Instance(R)'s antecedent is true in M: z ∈ R, and R climbs. (D5 — reached in zero steps; one more s preserves reachability. Chain 1's Steps 5–6, verbatim.)

B12. So Instance(R)'s consequent is true: every object of D is in R — R = D. (R4 on B10, B11.)

B13. That contradicts B8 (R ≠ D). So B9's assumption fails: ☑ Verdict G2 — no formula carves R in M. (B8, B12.)

Both verdicts are in. What follows is the anatomy: how M survives every induction axiom while keeping its aliens, and why Chain 1's proof was never transferable. (This stretch was first delivered in metaphor — "credentials," "inflates," "the wall" — and rejected; the expansion below replaced it, and caught an error in the process: see B18.)

B14. Name the two conditions Instance(S)'s antecedent tests, for any set S: (a) z ∈ S; (b) S climbs. (The antecedent of Instance(S), split for reuse.)

B15. Any set S satisfying (a) and (b) contains all of R. (By (a), the object reached in zero steps is in S; by (b), if the object reached in n steps is in S, so is the one reached in n+1; R's members are exactly the objects reached in finitely many steps — D5.)

B16. Call S a breaker if S satisfies (a) and (b) yet S ≠ D. A breaker is exactly what makes Instance(S) false: true antecedent, false consequent — the one false row of the table. By B15, every breaker contains all of R and misses at least one alien. And R itself is a breaker: (a) and (b) by B11, R ≠ D by B8.

B17. Take any formula F and ask what M's survival of Ind_F requires. Two cases, split by the table: Case 1 — C_F fails (a) or (b): Instance(C_F) has a false antecedent, so it is true in M automatically, whatever else C_F looks like. Case 2 — C_F satisfies (a) and (b): then Instance(C_F) is true only if C_F = D; M survives, so C_F = D. (D1; the table.)

B18. So M survives every induction axiom because no formula carves a breaker: every carved set falls under Case 1 (true for free) or Case 2 (equals D — not a breaker). Breakers exist in M — R is one, and so is any set containing R that misses an alien — but the argument of B9–B13 runs verbatim with any breaker in place of R: were it carved, its own instance would force it to equal D, contradicting "misses an alien." The sets that would falsify induction are sets no axiom of Σ ever speaks about. (B13, B16, B17.) — Correction the expansion caught: an earlier draft said "R alone has the credentials without being D." False — every breaker does. The argument needs, and has, all of them uncarved.

B19. Why Chain 1's proof does not transfer — the actual strings side by side. The second-order axiom is the single sentence Ind := ∀P(…), and by R3, "Ind true in M" unpacks to Chain 1's guarantee, quoted:

Step 2. For every subset S of D, Instance(S) is true in M.

— one true conditional per subset, no exceptions — which Chain 1 cashed out at R in two moves (Step 4: R ⊆ D, subsethood the sole ticket; Step 7: Instance(R), the cash-out). Σ contains no sentence Ind — the string ∀P is not in its grammar; in its place stand the separate axioms Ind_F, and what survival of Σ guarantees is only:

For every formula F, Instance(C_F) is true in M.

The index set changed: subsets of D → carved sets of M. R's subsethood buys nothing; to reproduce Chain 1's Step 7 you would need R in the new index set — some F with C_F = R — and B13 says there is no such F in M. Instance(R), the one conditional whose truth forces R = D and kills the aliens (Chain 1, Steps 7–9), is in M false — true antecedent by B11, false consequent by B8 — a false instance sitting in the world, asserted by no axiom on the list. Σ never says the one thing that would convict M. ∎

The picture.

        R (reached)          ‖   aliens (unreached)
   z → s(z) → s(s(z)) → ⋯    ‖   ⋯ → a → s(a) → s(s(a)) → ⋯
                             ‖
   the boundary ‖ is drawn by NO formula (B13):
   carved + (a) + (b)  →  the set is all of D          (B17, Case 2)
   R has (a) + (b) and is not all of D                 (B16: a breaker)
   →  R is not carved — nor is any other breaker       (B18)

Coda — the ticket change, and a named pitfall (not load-bearing).

second-order Ind:   guarantee indexed by SUBSETS      — R's ticket: R ⊆ D          ✓  (Chain 1, Step 4)
first-order Σ:      guarantee indexed by CARVED SETS  — R's ticket: some C_F = R   ✗  (B13)

Counting makes the ticket change costly — formulas are finite strings, so only listably many carved sets, against unlistably many subsets (the Ch. II diagonal). But the pitfall, named once: "uncarved sets exist, therefore aliens exist" is invalid. ℕ itself has unlistably many uncarved subsets and zero aliens. Sparse coverage merely fails to forbid alien worlds; what produces one is B1–B6 — adequacy plus the machine limit, nothing else. Nor is the reverse route circular: "alien world ⇒ R uncarved" (B9–B13) is a conditional theorem whose hypothesis is discharged by the existence theorem (B1–B8); the arrows never close a loop. In copies, R is carved — by (v₁ = v₁).


Part VIII — Distinctions Ledger

Confusion raised One-line resolution
"These axioms don't look like universal truths — more like sentence structures" Correct, twice over: the schemes are metalanguage stencils (instances are the axioms), and "correct" means true in the intended interpretation — chosen truths, not self-evident ones.
"If F is true, 'G ⊃ F' isn't automatically true, is it?" Under the table it is: G ⊃ F is false only at (G true, F false), excluded by F's truth. ⊃ is the table, not English "if–then"; the discomfort is the paradoxes of material implication, and the table is forced by wanting ∀-claims to mean "no counterexample."
Why exactly these 19 schemes — could more be discovered? Chosen toolkit, not discovered totality: constraints are correctness + shape-recognizability + sufficiency. Logic side: provably finished (adequacy 1930). Arithmetic side: provably never finishable (1931) — the impossibility of ending the search is the theorem.
"Completeness theorem" vs "incompleteness theorem" Different objects: 1930 is about the engine (prints all logical consequences — renamed adequacy); 1931 is about systems aiming at T. They compose: the engine is perfect; no axiom stock ever makes consequence reach T.
"Interpretation" used but never defined Domain + referent for 0̄ + meanings for ′, +, ·, E, ≤. Truth exists only relative to one. Rivals evaluated: clock-12, one-object world.
"First-order never claims truth covering all natural numbers" Inverted: ∀v₁ covers all numbers; what first-order cannot say is "for all properties." The divide is that one grammar clause.
First-order's smaller obligation as a post-Gödel "retreat" No agency, no timeline: the duty was always "true in all survivors" by definition; impostors surviving is what keeps it below T. The leak is why the finish is reachable.
"Dedekind proved second-order logic complete (every truth provable)" He proved categoricity — a statement about interpretations only; no proof-concept occurs in it.
"Gödel proved all machines are adequate" 1930 says one adequate engine exists, for first-order. Almost no machine is adequate.
What forbids second-order truths being finite strings? Nothing — they are finite strings, and second-order proof machines exist and run fine. What is impossible is one machine printing exactly the valid set: its duty contains all of T.
Why does ∀P inflate the duty to all of T? See-saw + drain: duty = true-in-all-survivors; ∀P lets induction test every subset of any world, draining survivors to ℕ-copies; then true-in-all-survivors = T by definition, not by ambition.
How does Step 2 lead to Step 4 — which instance? Does Ind's content matter? Missing rule, now stated (R3): ∀P's instances are indexed by subsets; subsethood is R's entry ticket (Step 4); Instance(R) is the specific conditional "z ∈ R and R climbs ⇒ R is everything" — the content is everything, and R4 turns it into no-junk.
C_F := {x ∈ D : F true of x in M} — "x belongs to D and F is true"? Set-builder: a membership test, not a conjunction — the set of those x passing it. It is Ch. II's "set F expresses," relativized to M; depends on both F and M.
"Gödel's first theorem establishes that impostors exist" Corollary, not content: book proves the unprovable truth; impostors follow in four lines given adequacy.
"First-order logic is incomplete" Terminology: the logic (engine) is adequate — flawless; first-order arithmetic systems are incomplete.
"Impostors survive" vs "provables sit below truths" — same claim? Different ledgers: worlds vs sentences. Pool-fact vs print-list-fact, welded by adequacy (print = duty). And only loud impostors (disagreeing with ℕ on a sentence) shrink the duty; quiet ones don't. The arrow runs print-gap → loud impostor, never backward.
"Why is R not carved? Assuming R ≠ D looks circular" No circle: "alien world ⇒ R uncarved" is a conditional theorem (B9–B13); alien-existence has its own proof (B1–B8); neither cites the other's conclusion. In copies R is carved (v₁ = v₁).
"Uncarved sets exist (counting), so aliens exist" Invalid — the named pitfall: ℕ has unlistably many uncarved subsets and zero aliens. Counting explains the stall; only adequacy + the machine limit produce an impostor.
"…so first-order can't compress, so an adequate machine exists" Reversed arrow: adequacy is a theorem proved outright — a premise (B1). With adequacy fixed, the see-saw forces compression to give (B6), not the other way.
"Credentials," "inflates," "the wall" (tutor's shorthand, rejected) Cashed out: credentials = the antecedent pair (a) z ∈ S, (b) S climbs (B14); inflate = forced to equal D by the set's own instance (B17); the wall = the R/alien boundary no formula draws (B13). Expansion caught a real error — see next row.
A stalled proof vs a refuted claim Chain 1's non-transfer (B19) diagnoses; it demonstrates nothing about survivors. "R alone is the dangerous set" was also false — every breaker (B16) is dangerous, and B18 shows none is carved.

Part IX — Self-Test

Answer before peeking.

  1. Scheme vs axiom: what is L₁, what are its axioms, and which groups' schemes have exactly one instance?
  2. The two senses in which P.E.'s axioms are correct — and one concrete rival interpretation with the axiom it falsifies.
  3. State the table for ⊃ and derive it from the "no counterexample" reading of a universal claim. Then verify L₁ by cases.
  4. Define: interpretation, survivor, copy, impostor, logical consequence, duty, adequate, complete, categorical.
  5. The three theorems (Dedekind 1888, Gödel 1930, Gödel 1931), one line each — and what each is about (interpretations? engines? systems?).
  6. State R3. What exactly is Instance(S) for Ind, and what are the two directions of use of a universal?
  7. Reproduce Chain 1 (twelve steps with justifications). At which single step does second-order grammar act, and what is R's "entry ticket"?
  8. Run the conviction backward: in the alien world, show Instance(R) is false and conclude Ind fails there. Why can't S1, S2 see the aliens?
  9. In the alien world, evaluate Instance(S) at S = the whole domain. True or false? What does the answer say about why the conviction had to use R? (Also still owed from session — see Part X.)
  10. The six-step syllogism: why no adequate machine for second-order logic. Which steps are definitions, which are theorems?
  11. The four-line impostor corollary: derive impostor-existence for P.E. from 1931. Which debt does it carry?
  12. Why does the first-order induction scheme cover only "a countable slice of an uncountable totality"? Cite the two Ch. II facts doing the work.
  13. State Part VII's two verdicts G1 and G2, and give the chain to G1 (B1–B6). Which two aerial debts does it lean on, and at which steps?
  14. Define breaker. Show every breaker contains all of R, and explain — with the two cases of B17 — how M survives every Ind_F despite containing breakers.
  15. Grade this inference: "there are countably many formulas but uncountably many subsets, therefore impostors exist." Then grade: "R is uncarved, therefore aliens exist."

Answers

  1. L₁ = (F ⊃ (G ⊃ F)), a metalanguage stencil, not a formula; its axioms are the instances with actual formulas plugged in. Group III's eleven schemes have one instance each (they contain no placeholders); Groups I, II, IV have infinitely many.
  2. Groups I–II: valid — true in every interpretation, by the meaning of the logical symbols alone. Groups III–IV: correct — true in the intended interpretation specifically. Rival: the twelve-hour clock falsifies ∼(0̄ = v₁′) (11′ = 0) while passing (v₁ + 0̄) = v₁.
  3. F ⊃ G false only at (T, F). Forced because "for every n: F(n) ⊃ G(n)" must mean "no counterexample": instances (T,T), (F,T), (F,F) must not break it — check divisible-by-4/even at n = 8, 6, 3. L₁: F true → G ⊃ F has true consequent, true, whole is T⊃T; F false → false antecedent, true.
  4. Interpretation: domain + referent for 0̄ + meanings for ′, +, ·, E, ≤. Survivor: makes all axioms true. Copy: ℕ renamed, same sentences true. Impostor: survivor, not a copy. Consequence: true in all survivors. Duty: the consequence-set of the fed axioms. Adequate: print list = duty, exactly. Complete: sound and prints all of T. Categorical: survivors = copies of one world.
  5. Dedekind: second-order Peano axioms are categorical — about interpretations only. 1930: an adequate engine exists for first-order logic — about the engine. 1931: no machine sound for T prints all of T (equivalently: no machine prints exactly T) — about every system aiming at arithmetic truth.
  6. R3: ∀Pφ true in M ⟺ for every subset S of D, φ with P(t) read as "t's value ∈ S" is true. Instance(S) = "if z ∈ S and S climbs, then every object of D is in S." Uses: one false instance falsifies; a true universal cashes out at any chosen instance.
  7. Part V verbatim. Second-order grammar acts only at Step 7 (the cash-out at S := R, licensed by R3). Entry ticket: subsethood alone (Step 4) — describability appears nowhere in R3's index set.
  8. R = the numbers; antecedent of Instance(R) true (0 ∈ R, successors of numbers are numbers); consequent false (aliens ∉ R); Instance(R) = T ⊃ F = false; by R3(i) Ind is false in M*. S1, S2 police only loops and merges — the alien ladder has neither; junk is invisible to the successor axioms.
  9. True — vacuously informative: at S = D, the consequent "every object is in D" is automatically true, so Instance(D) holds. The conviction needed a subset whose antecedent holds while its consequent fails — only the world's own reachable part R does that in a junk world; easy subsets prove nothing.
  10. Part VI. Steps 1 and 4 are definitions; Step 2 is Chain 1 (Dedekind); Step 5 is 1931; Steps 3 and 6 are combinations.
  11. Provable = true in all survivors (adequacy — the debt); G unprovable ⇒ false in some survivor M; ℕ survives with G true; M ≠ copy ⇒ impostor.
  12. Formulas are listable (finite strings over a finite alphabet — Ch. II listing); sets of numbers are not (Ch. II diagonal: any list of sets misses D = {n : n ∉ Sₙ}). One axiom per formula ⇒ induction guaranteed only at listably many properties out of unlistably many.
  13. G1: Σ does not compress ℕ (some survivor is not a copy). G2: in that survivor, no formula carves R. Chain to G1: adequate machine loaded with Σ prints its duty (B1, debt: adequacy); suppose compression (B2); ℕ survives (B3); then duty = T (B4); machine prints exactly T (B5); contradicting the machine limit (B6, debt: general machine form of 1931) — so compression fails. Debts at B1 and B6.
  14. Breaker: a set with (a) z ∈ S and (b) S climbs, yet S ≠ D — exactly what makes Instance(S) false. Contains R: by (a) the zero-step object is in, by (b) each further step stays in, and R is exactly the finitely-reached objects. B17: for each F, either C_F fails (a)/(b) — Instance(C_F) true by false antecedent — or C_F has both and, since M survives, C_F = D. Either way no carved set is a breaker; the breakers (R among them) are sets no axiom speaks about.
  15. Both invalid. First: ℕ has uncountably many uncarved subsets and zero aliens — counting explains the stall, never produces an impostor; impostors come from adequacy + the machine limit (B1–B6). Second: reversed — "R uncarved" is proved from alienhood (B9–B13, a conditional theorem); in copies R is carved by (v₁ = v₁).

Part X — Position, pending items, debts, and the method

Position: Chapter III begun. §1 (the axiom system P.E.) read and conceptually consolidated — what the nineteen schemes are, why correct, how they cohere. (July 25 update: the meaning-by-meaning walk deferred below is now substantially done — Part XI records N₁–N₁₁ under their official numbers, corrects the L₅/L₇/N₁₂ strings against the page, and unpacks the Discussion paragraph's claim that substitution and free/bound are circumvented.) The chapter's formal work is untouched: the meaning-by-meaning walk through the remaining axioms was deferred for the excursus, and §2 (arithmetization of the axiom system — "x is a proof of y" becoming an arithmetic relation) is where the book resumes. Part XI makes the connection concrete: the axioms were engineered — occurrence-scans and one-cut replacement instead of substitution — so that "x is an axiom" will cost §2 only concatenation. Note the connection already visible: the arithmetization is exactly what makes any machine describable inside arithmetic, which is what powers 1931's diagonal — the engine under every candidate truth-printer.

Owed by the reader, three items: (1) the L₃ case-check — ((∼F ⊃ ∼G) ⊃ (G ⊃ F)) across the four truth-value combinations, using only the table; (2) the ancestor interpretation — find an interpretation falsifying (v₁ ≤ v₂ ∨ v₂ ≤ v₁) (hint on record: domain = people, ≤ read as "is an ancestor of"); (3) the whole-domain instance — Self-Test 9.

Debt register: the standing four (E-elimination; prime base 13; property 1 ⇒ property 2; mechanical ⇒ Arithmetic) plus three new, all confined to the aerial commentary and not on the book's route: (5) the 1930 adequacy theorem — load-bearing for the four-line corollary, the see-saw, and B1; (6) the general machine form of 1931 (the machine limit) — Chapter III proves it for P.E.; the widening to all machines comes in the later abstract chapters; now load-bearing for B6; (7) operation-agreement — that a survivor with R = D is a full copy (the numerals' successor chain is Chain 1's Steps 10–11; that +, ·, E, ≤ agree with ℕ's tables on named objects is asserted, not derived) — load-bearing for B8. A former eighth — the existence of worlds where no formula carves R — is no longer a debt: it is theorem B13. The July 25 continuation adds one: (8) instantiation from L₆ + L₇ — that the missing axiom ∀v₁F ⊃ F(t) is recoverable as a theorem from L₆, L₇, Groups I–II and the two rules (asserted in Part XI §7, not derived; it is part of what the Kalish–Montague formulation's adequacy amounts to).

The method — a third failure mode, a new tool, and the continuation's lessons. July 22: vivid coinages doing load-bearing work stall explanations. July 23: both over-compression and natural-language paraphrase fail; the channel is symbols + justified chains. Today found the third failure mode: metaphor stacking — "treadmill," "finish line," "blueprint," several per paragraph, each carrying real content but none cashed out ("I don't know what it is, maybe your language, maybe your analogies — I find your explanation hard to comprehend"). What worked, in order of discovery: (a) plain single-vocabulary restatement (machines/printing) — partial; (b) the reader stating his own understanding for piece-by-piece grading — effective, and errors localized precisely; (c) a glossary of citable definitions fixed before any argument, then theorems, then chains — the reader's own prescription, and the turning point; (d) full expansion with evaluation rules stated as numbered citable items — the diagnosis that a chain stalls when a justification silently uses a rule never stated (R3, the instance rule, was the entire Step 2→4→5 gap). New tool for the kit: when a learner cannot cross a step, look for the unstated rule before adding more prose. The continuation added two more: (e) audit the arrow directions — the reader's circularity challenge was resolved only by separating a conditional theorem from an existence theorem, and grading his proposed chain exposed a premise (adequacy) sitting in the conclusion slot; (f) expand every metaphor into steps, because the expansion is a checker — cashing out "credentials/inflates/the wall" surfaced a genuine error ("R alone") that the imagery had hidden. And the complementary reader's-side skill, displayed twice: tracking the dependency structure of an argument — first to drop what was not load-bearing, then to demand the rebuilt version stand as one chain with stated objective and verdicts.

The July 25 continuation added two more tools. (g) Teach new material as a delta against an owned result. The first explanation of the Kalish–Montague system, built from scratch, failed ("your way of elucidation doesn't really help me"); what landed was the reader's own anchor — "we had our own substitution via a wrapper on July 22 — what is different here?" — after which everything became one comparison: same trick, one precondition-failure, one repair. New material that echoes an owned result should be taught as the diff, not as a fresh subject. (h) A felt contradiction is data — locate the invalid step, then find where the instinct is right. "It still reads like v₁ = v₁′" dissolved not by reassurance but by (i) naming the exact invalid move (transitivity across a re-binding: no single context holds both guards) and (ii) showing the string on which the instinct is correct (the single-wrapper attempt, where the guard genuinely is contradictory). An objection traced to the diseased neighbor it correctly diagnoses is worth more than an objection merely answered.


Part XI — Second continuation (July 25): the N₁₂ brackets are the July 22 wrapper; replacement vs substitution

Triggered by the reader holding this file against the book's pages 29–30 and finding it short: (i) not all schemes were recorded — N₁–N₁₁ never stated, L₅/L₇/N₁₂ misstated (now corrected in place, marked); (ii) the Discussion paragraph claims substitution — "indeed, even the notions of free and bound occurrences of variables are circumvented" — how?; (iii) the reader's own recall, which became the key to everything: "on July 22 we had our own version of substitution via a wrapper — what is different here?"; (iv) a precise objection to the answer: "the double-guarded string still reads like v₁ = v₁′ — a contradiction?" A first explanation, built from scratch, failed ("your way of elucidation doesn't really help me"); the one that landed is below, organized around (iii). All July 22 items (Φ_lit, Φ_wrap, the three layers, the four hazards, r, sub) are used under their own names.

N₁–N₁₁, recorded under their official numbers — exactly Part I's ladder and recipes, now tied to the strings:

N₁  : (v₁′ = v₂′ ⊃ v₁ = v₂)              — different rungs, different nexts
N₂  : ∼(0̄ = v₁′)                          — 0 is nobody's next
N₃  : (v₁ + 0̄) = v₁                       ┐
N₄  : (v₁ + v₂′) = (v₁ + v₂)′             ┘ the addition recipe
N₅  : (v₁ · 0̄) = 0̄                        ┐
N₆  : (v₁ · v₂′) = ((v₁ · v₂) + v₁)       ┘ multiplication = repeated addition
N₇  : (v₁ ≤ 0̄ ≡ v₁ = 0̄)                  ┐
N₈  : (v₁ ≤ v₂′ ≡ (v₁ ≤ v₂ ∨ v₁ = v₂′))  │ ≤ characterized stepwise
N₉  : ((v₁ ≤ v₂) ∨ (v₂ ≤ v₁))             ┘ any two numbers comparable
N₁₀ : (v₁ E 0̄) = 0̄′                       ┐
N₁₁ : (v₁ E v₂′) = ((v₁ E v₂) · v₁)       ┘ E = repeated multiplication

(N₁, N₂ are Part V's S2, S1 up to the outer ∀ — supplied by the generalization rule — and the order of the equation.)

§1. The brackets are the July 22 brackets — and the wrapper's real precondition. F[0̄] = ∀v₁(v₁ = 0̄ ⊃ F) is Φ_wrap(F, 0) verbatim (July 22, Part IV). And rereading Φ_wrap(F, t) = ∀v₁(v₁ = t ⊃ F) with fresh eyes: its precondition was never "t is a numeral." It is: t contains no v₁ — nothing for the added quantifier to grab. Numerals satisfy this trivially (they contain no variables at all), and Chapter II never tested the boundary, because diagonalization only ever plugs specific codes.

§2. The boundary tested: plugging v₁′, and capture. Induction's climbing slot must evaluate F at v₁′ — a term containing v₁. Feed it to the single wrapper and watch:

∀v₁(v₁ = v₁′ ⊃ F)

The new ∀v₁ grabs every v₁ in its scope — including the one inside the term, which was supposed to keep pointing at the outside number. (Standard name: capture — a variable meant to stay free is seized by an added quantifier.) Run on F := ∃v₂(v₁ = v₂ + v₂), "v₁ is even": the string says "every number that equals its own successor is even" — guard false of everything, sentence vacuously true, content destroyed.

§3. The repair: reduce the new case to the old one.

F[v₁′]  :=  ∀vᵢ( vᵢ = v₁′ ⊃ ∀v₁( v₁ = vᵢ ⊃ F ) )        (vᵢ any variable not occurring in F)

A fresh variable vᵢ satisfies the precondition — a term containing no v₁, the same property the numeral had. The outer guard sits outside the inner ∀v₁'s scope, so its v₁ still points outside: it stores v₁′'s value under the fresh name. The inner string is Φ_wrap(F, vᵢ) verbatim. So the double wrapper is not a new trick: trade the dangerous term for a harmless fresh variable, then run the old machine unchanged. The freshness condition is the same disease one level up (if vᵢ occurred in F, the outer ∀vᵢ would grab those occurrences) — and it is checked by a bare symbol-scan, not a scope-parse.

§4. The semantic parse — Claim A, and N₁₂ = the domino principle. (This also retro-earns Part V's parse "Ind_F in M says exactly Instance(C_F)," which was stated there in substitution notation; the chain below establishes it for the book's actual bracketed string, so every use in Parts V–VII stands.)

Claim A: F[v₁′] is true at n ⟺ F is true at n+1 ("true at k" = true with v₁ read as k). Evaluate at v₁ := n:

  1. The inner ∀v₁ re-binds only its own scope, (v₁ = vᵢ ⊃ F); the v₁ inside the term v₁′ sits outside that scope, so v₁′ denotes n+1. (R1; the whole reason the guard is placed outside.)
  2. Outer ∀vᵢ: true ⟺ for every m, the instance (m = n+1 ⊃ ∀v₁(v₁ = m ⊃ F)) is true. (R2.)
  3. m ≠ n+1: false antecedent, instance true, no information. (Table.)
  4. m = n+1: instance true ⟺ ∀v₁(v₁ = n+1 ⊃ F) is true. (Table.) The stored value has been handed over; vᵢ is gone.
  5. That string is Φ_wrap(F, n+1): by R2 and the table, k ≠ n+1 passes vacuously, k = n+1 says: F is true at n+1. (July 22's equivalence, re-derived.) ∎

Concrete run, F := 0̄ ≤ v₁, n = 4: v₁′ denotes 5; only vᵢ = 5 survives Step 2–4; only k = 5 survives Step 5; verdict "0 ≤ 5". F consulted once, at the end, unopened — the two wrappers are a delivery pipe for the value n+1. Claim B: F[0̄] is true ⟺ F is true at 0. (Step 5 with 0 in place of n+1.)

Assembling N₁₂ (a sentence — every v₁ ends up bound): by Claim B, block 1 = "F holds at 0"; by R2 with Claim A inside every instance, block 2 = "for every n: F at n implies F at n+1" — F climbs; block 3 = "F holds at every number." Reading the two ⊃'s by the table:

(F at 0) ⊃ ((F climbs) ⊃ (F everywhere))

— false in exactly one situation: F holds at 0, F climbs, yet F fails somewhere. The domino principle for the set carved by F; in a world M, exactly Instance(C_F). And each instance is true of ℕ (the ladder has no side-branches and no unreachable rungs), so constraint (a) of Part I holds. ∎

§5. The transitivity objection, and regions. The reader: "it still reads like v₁ = v₁′ — v₁ = vᵢ and vᵢ = v₁′ chain to a contradiction." The resolution, with the run at v₁ := 4 on the table:

region of the string v₁ denotes v₁′ denotes vᵢ denotes
outside everything 4 5 —
inside ∀vᵢ only (guard 1 lives here) 4 5 5
inside both quantifiers (guard 2 and F live here) re-bound to each k; weight at 5 6 — unused; guard 1 does not live here 5

At the moments they are checked, guard 1 says 5 = 5 and guard 2 says 5 = 5; the alarming "4 = 5" is asserted by no part of the string. Transitivity chains equations that hold in one context — and between the guards, ∀v₁ re-points the letter, so no single context holds both. (Re-read inside the inner region, guard 1 would even be false — 5 = 6 — harmlessly: it lives outside, was checked with v₁ meaning 4, and its work, pinning vᵢ to 5, is done. vᵢ is the one letter with constant denotation: it is the pipe.) And the instinct is the correct diagnosis of the single-wrapper string (§2), where both sides of v₁ = v₁′ share one region and the guard genuinely is contradictory — the cure works precisely by making the transitivity chain unrunnable.

Why reuse the letter v₁ at all? Because the transparent alternative — rename F's free variable and write ∀vᵢ(vᵢ = v₁′ ⊃ ∀w(w = vᵢ ⊃ F⟨w⟩)) — requires editing every free v₁ inside F into w: renaming is substitution, the forbidden operation. F arrives with its free variable unchangeably named v₁, so the delivery pipe must terminate in a quantifier over that exact letter, and the letter serves two masters, disambiguated by scope alone. A shape-checking machine never stumbles (which quantifier owns which occurrence is fixed mechanically by nesting); only human reading trips, because it wants one letter to mean one thing.

§6. Why v₁′ and not a numeral — essential vs circumstantial. The reader asked whether the whole apparatus is an accident of this one axiom. Split verdict:

The v₁-containing plug is essential. The climbing slot asserts infinitely many climb-steps at once — (0,1), (1,2), (2,3), … — and the numeral alternative, the infinite list F[0̄] ⊃ F[0̄′], F[0̄′] ⊃ F[0̄′′], …, fails on the definition of proof itself: (1) a proof is a finite sequence of formulas; (2) so any one proof uses finitely many climb-sentences; (3) so it reaches F[n̄] for some n and no further; (4) ∀v₁F(v₁) — the thing induction exists to deliver — would never be provable, though every instance would be. One finite quantified sentence, evaluating F at v₁′ under the binder, is the only shape that works. And Group IV is the only plugging site among the nineteen schemes — the only scheme parameterized by an arbitrary formula. (Group III mentions v₂′ constantly — N₄ — but those are honest terms written into fixed atomic equations as they are composed, not plugs into a pre-existing formula.)

The delivery device is the choice. Gödel states the same content with literal substitution F(v₁′) and pays with the sub ladder; Smullyan's guards are the alternative implementation — forced for him by the standing refusal to build sub.

§7. Replacement vs substitution — the July 22 hazard list, walked. Two string operations (layer 1 of July 22's three layers):

  • Substitution (Φ_lit): open F; find the occurrences of v₁; determine which are free (parse parenthesis scope); replace each of them; reassemble. The four hazards; the ~31-rung ladder for sub.
  • Replacement (L₇'s notion): one cut, one splice, in an atomic formula: X₁vᵢX₂ ↦ X₁tX₂.

The hazards die one by one: find all occurrences — gone (one occurrence, any one you like); which are free — gone (atomic = no ∀ inside = nothing bound, nothing to parse); capture — impossible (no quantifier in the string to do the grabbing); the code function — one concatenation, a ∗ b ∗ d ↦ a ∗ c ∗ d, Corollary 1 territory. Slogan: substitution must be parsed; replacement only cut.

And the system has no instantiation axiom ∀v₁F ⊃ F(t) — the usual home of "substitute t for the free v₁," with its capture-avoidance side condition. Its work is done by L₆ (the term has a value: ∃vᵢ(vᵢ = t)) plus L₇ transferring atomic facts across vᵢ = t one occurrence at a time — instantiation becomes a theorem to derive, not an axiom to state (asserted, not derived here — debt 8). With that, the Discussion paragraph is fully cashed: "substitution for free occurrences" avoided = no instantiation axiom + brackets in N₁₂; "free and bound circumvented" = every side condition (L₅, L₆, Group IV's freshness) is an occurs-at-all scan; "the simpler notion of replacement" = L₇'s one cut in an atomic formula. L₆'s own side condition is the grabbing disease once more: without "vᵢ not in t," ∃v₁(v₁ = v₁′) — "some number is its own successor" — would be an axiom, and false.

§8. Who the customer is — the same economy, twice. July 22's three layers: string operation → code function → naming formula; all cost lives in layer 3. In Chapter II the operation needing a named code function was diagonalization: the wrapper bought r(x, y) = k ∗ 13ʸ ∗ 8 ∗ x ∗ 3 — x riding unopened, layer 3 one line — and sub was never built. In Chapter III the thing needing a layer-3 formula is "x is the code of an axiom" — the first ingredient of "x is a proof of y," which is §2's whole burden. Under the bracket definition, an induction axiom's code is fixed blocks ∗ F's code ∗ fixed blocks — F an unopened parcel in every slot; the occurrence-scans are substring conditions; L₇'s replacement is the concatenation statement above. Had the schemes been stated with literal substitution, the axiom-recognizer would need sub Arithmetic — the ladder. Same refusal, new beneficiary: the wrapper protected the diagonal's address in Chapter II; it protects the axiom-checker in Chapter III. sub is never built anywhere in the book.

Ledger additions (July 25).

Confusion raised One-line resolution
"Isn't this just our July 22 wrapper?" Yes — F[0̄] is Φ_wrap(F, 0) verbatim. New is only the plug: v₁′ contains v₁, violating the wrapper's real precondition (plug free of v₁ — "numeral" was never the condition); repair = outer guard trades v₁′ for a fresh variable, inner wrapper unchanged.
"Replacement as opposed to substitution?" Substitution: parse F, find free occurrences, replace all — four hazards, the sub ladder. Replacement: one cut-and-splice in an atomic formula — nothing bound, capture impossible, code function one concatenation. Parsed vs cut.
"v₁ = vᵢ and vᵢ = v₁′ — so v₁ = v₁′, contradiction?" The inner ∀v₁ re-points v₁ between the guards (4 → 5 in the run); each guard, when checked, says 5 = 5; no single context holds both, so transitivity cannot fire. The instinct correctly diagnoses the single-wrapper string, where the guard genuinely is contradictory.
"Why reuse the letter v₁ at all?" Renaming F's free variable = opening F = substitution. The pipe must end in ∀ over the exact letter F uses; scope disambiguates mechanically.
"Is the double wrapper circumstantial?" Split: plugging a v₁-containing term is essential (finite proofs — a numeral climb-list yields every instance but never ∀v₁F); the guards-vs-surgery delivery is the design choice (Gödel pays the ladder instead).
"How exactly are free/bound circumvented?" No instantiation axiom to state; every side condition an occurs-at-all scan; the one replacement site atomic, where nothing is bound.

Self-Test additions (16–21). Answer before peeking; these extend Part IX.

  1. State the wrapper's real precondition, and exhibit the capture failure of the single wrapper at F := ∃v₂(v₁ = v₂ + v₂).
  2. Reproduce Claim A's five-step parse. Where exactly is "vᵢ does not occur in F" spent?
  3. At v₁ := 4, give the three regions of F[v₁′] and what v₁, v₁′, vᵢ denote in each. Which letter is constant, and what does that constancy express?
  4. Why can induction not climb by numerals? Four steps, starting from the definition of proof.
  5. Walk replacement through the four-hazard list, and say why atomicity alone kills capture.
  6. Which axiom does the system not have, what pair does its work, and which false sentence does L₆'s side condition exclude?

Answers

  1. The plug t must contain no v₁ — nothing for the added ∀v₁ to grab; numerals satisfy it vacuously. ∀v₁(v₁ = v₁′ ⊃ ∃v₂(v₁ = v₂ + v₂)) says "every number equal to its own successor is even" — guard false everywhere, sentence vacuously true, content gone.
  2. §4. Spent at Step 5's "F is true at n+1": reading F's truth as depending only on v₁ presupposes no occurrence of vᵢ in F — otherwise the outer ∀vᵢ would have re-bound those occurrences to n+1, corrupting F before it was consulted.
  3. Outside: v₁ → 4, v₁′ → 5, vᵢ undefined. Inside ∀vᵢ only: 4, 5, 5. Inside both: v₁ re-bound (weight at 5), v₁′ → 6 (unused — guard 1 lives outside), vᵢ → 5. Constant: vᵢ, always 5 — the stored value; the pipe carrying 5 from the region where v₁ means 4 into the region where v₁ has been re-bound.
  4. Proofs are finite sequences → any proof uses finitely many of F[0̄] ⊃ F[0̄′], F[0̄′] ⊃ F[0̄′′], … → it reaches F[n̄] for some n and no further → ∀v₁F(v₁) is never provable though every instance is. The climbing clause must be one quantified sentence, hence F evaluated at v₁′ under the binder.
  5. One occurrence (no iteration); atomic = no ∀ = no bound occurrence to identify; no quantifier inside = nothing can seize the spliced t; code function a ∗ b ∗ d ↦ a ∗ c ∗ d. Atomicity kills capture because capture is seizure by a quantifier, and an atomic formula contains none.
  6. Missing: instantiation, ∀v₁F ⊃ F(t). Its work: L₆ (∃vᵢ(vᵢ = t) — the term has a value) + L₇ (one-occurrence transfer across vᵢ = t), a derivation rather than an axiom (debt 8). L₆'s condition "vᵢ not in t" excludes ∃v₁(v₁ = v₁′) — "some number is its own successor," false.

End of session review · Smullyan, "Gödel's Incompleteness Theorems," Chapter III §1 conceptually consolidated (with the Part VII rebuild and the July 25 continuation, Part XI); formal work pending · 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), Godel-Incompleteness-Session-2026-07-23.md (Chapter II Exercises 6–8, complete) · Next: Chapter III proper — the L₃ check, the ancestor interpretation, Self-Test 9, then §2 arithmetization.