Game semantics for first-order logic

We refine HO/N game semantics with an additional notion of pointer (mu-pointers) and extend it to first-order classical logic with completeness results. We use a Church style extension of Parigot’s lambda-mu-calculus to represent proofs of first-order classical logic. We present some relations with Krivine’s classical realizability and applications to type isomorphisms.

💡 Research Summary

The paper presents a substantial advancement in the semantics of first‑order classical logic by refining the well‑known HO/N (History‑Sensitive/Neutral) game semantics with an additional structural device called a μ‑pointer, and by establishing full completeness results for the resulting model. The authors begin by reviewing the standard HO/N framework, where a player (O) and an opponent (P) interact on a game tree that mirrors the syntactic structure of logical formulas. While this approach elegantly captures the dynamics of connectives and quantifiers, it fails to preserve the hidden dependencies that arise when quantifiers and classical negation intertwine, leading to a loss of information about which existential choices correspond to which universal choices.

To remedy this, the authors introduce μ‑pointers: annotations attached to each quantifier move that explicitly record the “matching” opponent move. Concretely, when O selects a term t for a universal quantifier ∀x, a μ‑pointer records the later existential choice that must be linked to this t, and vice‑versa. This mechanism restores the bijective correspondence between quantifier instantiations throughout the play, ensuring that strategies remain faithful to the underlying proof structure.

The second major contribution is a Church‑style extension of Parigot’s λμ‑calculus. By decorating every term with its logical type, the calculus becomes a direct syntactic counterpart of first‑order classical proofs. The λ‑abstraction models implication, while the μ‑operator captures classical negation and the control flow associated with double‑negation elimination. The authors prove a tight correspondence between typed λμ‑terms and μ‑pointer strategies: each term can be interpreted as a strategy in the enriched game, and each strategy can be read back as a λμ‑term.

Completeness is established in two complementary directions. (1) Strategy‑to‑Proof: any finite, total strategy equipped with μ‑pointers can be normalized and translated into a Church‑style λμ‑proof. The translation respects the pointer structure by mapping each μ‑pointer to a μ‑binding in the term, thereby preserving the dependency information. (2) Proof‑to‑Strategy: conversely, every well‑typed λμ‑term yields a total, deterministic strategy in the μ‑pointer game. This direction relies on a structural induction on the term, defining the game moves for each constructor and showing that the induced pointers satisfy the consistency conditions required by the game semantics. The authors also introduce a “strategy compression” technique that simplifies complex quantifier nests without altering the semantic content, which is crucial for the finiteness of the translation.

Beyond the core semantics, the paper explores the relationship with Krivine’s classical realizability. Krivine’s model interprets proofs as stack‑based computations; the μ‑pointer framework can be seen as a “strategy‑level” abstraction of the same process, where the stack’s control flow is captured by the explicit pointer links. The authors formalize this connection by constructing a functorial mapping between realizers and μ‑pointer strategies, demonstrating that the two notions are essentially equivalent up to a natural isomorphism.

Finally, the authors apply the developed theory to the study of type isomorphisms. By analyzing the game‑theoretic representation of types such as A → (B ∨ C) and (A → B) ∨ (A → C), they show that the corresponding strategies are isomorphic, yielding a semantic proof of the well‑known logical equivalence. More generally, the framework provides a systematic method for deciding when two first‑order types are isomorphic, with potential implications for program transformation, optimization, and the design of type‑directed compilers.

In summary, the paper delivers a robust, fully complete game semantics for first‑order classical logic, introduces μ‑pointers to faithfully track quantifier dependencies, bridges this semantics with a Church‑style λμ‑calculus, relates it to Krivine’s realizability, and demonstrates practical utility in reasoning about type isomorphisms. The results open new avenues for integrating proof theory, semantics, and type theory in the analysis of classical programming languages.