Partiality and Recursion in Higher-order Logic

We present an illative system I_s of classical higher-order logic with subtyping and basic inductive types. The system I_s allows for direct definitions of partial and general recursive functions, and provides means for handling functions whose termination has not been proven. We give examples of how properties of some recursive functions may be established in our system. In a technical appendix to the paper we prove consistency of I_s. The proof is by model construction. We then use this construction to show conservativity of I_s over classical first-order logic. Conservativity over higher-order logic is conjectured, but not proven.

💡 Research Summary

The paper introduces an illative higher‑order logic system called Iₛ, which extends classical higher‑order logic (HOL) with subtyping, basic inductive types, and, crucially, the ability to define partial and general recursive functions directly. Traditional HOL requires every defined function to be total and any recursive definition to be justified by a termination proof, typically via structural induction. This restriction makes it difficult to formalize many everyday programming constructs—partial functions, algorithms whose termination is not yet proved, or functions that deliberately diverge on certain inputs. Iₛ removes these constraints by adding two new logical constructs: a “bottom” constant (⊥) that explicitly marks undefined values, and a fixed‑point operator (μ) that yields the least fixed point of a possibly non‑terminating definition.

The syntax of Iₛ augments the usual HOL language with these symbols while preserving the familiar λ‑abstraction, application, and logical connectives. Types are refined through a subtyping hierarchy, allowing the system to distinguish between total and partial functions at the type level. Basic inductive types such as natural numbers, lists, and trees are built‑in, providing the usual induction principles for reasoning about them.

Semantically, the authors construct a model based on partial orders and complete lattices. Each type is interpreted as a complete lattice, and every term denotes a continuous function on these lattices. Continuity guarantees that as inputs become more defined, outputs become at least as defined, which is essential for handling partiality. The fixed‑point operator is interpreted as the least fixed point in the lattice, ensuring that even non‑terminating recursive definitions have a well‑defined meaning (often the ⊥ element). This framework yields a consistency proof: no contradiction can be derived because every axiom and inference rule is sound with respect to the lattice model.

Beyond consistency, the paper proves that Iₛ is conservative over classical first‑order logic. In other words, any first‑order theorem provable in Iₛ was already provable in ordinary first‑order logic; the extensions do not introduce new first‑order consequences. Conservativity over full higher‑order logic is conjectured but not established; the authors outline how their model could be extended to address this open problem.

To demonstrate practical relevance, the authors present several case studies. A partially defined sorting function is expressed using ⊥ to block the case of an empty list, illustrating how Iₛ can capture functions that are intentionally undefined on certain inputs. A stream‑generation function that produces an infinite list is defined via μ, showing that infinite data structures can be given a mathematically precise meaning without requiring a termination argument. Finally, a depth‑first search algorithm—whose termination depends on properties of the input graph—is formalized without a prior termination proof; the authors then prove correctness properties (e.g., visited‑node invariants) within Iₛ. These examples highlight that Iₛ can serve as a foundation for formal verification of realistic programs that mix total, partial, and potentially non‑terminating components.

The technical appendix details the lattice construction, the interpretation of subtyping, and the proof of the key lemmas that underpin consistency and first‑order conservativity. It also sketches a roadmap for future work: extending the conservativity result to full higher‑order logic, integrating Iₛ with automated theorem provers, and enriching the language with more sophisticated inductive and co‑inductive types. In sum, Iₛ offers a robust logical framework that bridges the gap between the expressive needs of modern programming languages and the rigor of classical higher‑order logic, opening new avenues for both theoretical investigation and practical program verification.