A Survey of the Proof-Theoretic Foundations of Logic Programming (2109.01483v2)

Abstract: Several formal systems, such as resolution and minimal model semantics, provide a framework for logic programming. In this paper, we will survey the use of structural proof theory as an alternative foundation. Researchers have been using this foundation for the past 35 years to elevate logic programming from its roots in first-order classical logic into higher-order versions of intuitionistic and linear logic. These more expressive logic programming languages allow for capturing stateful computations and rich forms of abstractions, including higher-order programming, modularity, and abstract data types. Term-level bindings are another kind of abstraction, and these are given an elegant and direct treatment within both proof theory and these extended logic programming languages. Logic programming has also inspired new results in proof theory, such as those involving polarity and focused proofs. These recent results provide a high-level means for presenting the differences between forward-chaining and backward-chaining style inferences. Anchoring logic programming in proof theory has also helped identify its connections and differences with functional programming, deductive databases, and model checking.

• The paper surveys how structural proof theory provides an alternative foundation for logic programming, extending it beyond classical first-order logic.
• Leveraging intuitionistic and linear logic via proof theory enables logic programming languages to capture stateful computations, modularity, and abstract data types.
• Concepts like uniform and focused proofs, rooted in proof theory, provide structured approaches to proof search and reasoning about programs.

The paper "A Survey of the Proof-Theoretic Foundations of Logic Programming" by Dale Miller provides a comprehensive examination of how structural proof theory serves as an alternative and enriching foundation for logic programming. Over the past 35 years, researchers have leveraged this foundation to transition logic programming from merely first-order classical logic to encompass higher-order versions of intuitionistic and linear logic. This transformation has yielded more expressive logic programming languages capable of capturing stateful computations and abstract representations, facilitating higher-order programming, modularity, and abstract data types.

The paper explores the exploration of logic programming through various lenses:

1. Foundations in Structural Proof Theory: Several formal systems traditionally underpin logic programming, such as resolution and minimal model semantics. Structural proof theory provides a robust alternative, enhancing logic programming beyond its conventional boundaries.
2. Higher-Order Logic and Intuitionistic Logic: The exploration begins with linking logic programming to higher-order logic through the use of hereditary and higher-order Horn clauses. Intuitionistic logic’s role is particularly emphasized in relation to proof search, where hypothetical and universally quantified goals bring forward features like modular programming and dynamic scoping.
3. Linear Logic: The introduction of linear logic by Girard brought fresh insights into handling stateful computations in logic programming. By incorporating linear implications, logic programming extended to allow for resource-sensitive computations and concurrent processes, illustrating this with languages like LO, Lolli, and Forum.
4. Goal-Directed and Focused Proofs: The concepts of uniform and focused proofs underscore much of the paper’s discussion on proof search strategies. Uniform proofs allow the application of right-introduction rules primarily for goals, while focused proofs extend this notion to linear logic and beyond, providing a structured approach to proof search that can distinguish between forward and backward reasoning.
5. Applications and Reasoning: The integration of proof theory into logic programming assists in addressing some limitations of simple Horn clauses by enabling reasoning about programs and their correctness, supporting modern programming abstractions, and handling complex data structures with binders through logical frameworks.
6. Comparative Analysis: The paper also presents a comparative view of how logic programming contrasts with functional programming, notably through the lens of the Curry-Howard correspondence, while identifying logic programming's unique aspects such as proof search as opposed to proof normalization which is typical of functional programming.
7. Challenges and Future Prospects: Addressing shortcomings such as constraints, control of search, and negative features like negation-as-failure, the paper posits that proof theory can lead to logic programming languages with features aligning with contemporary programming needs, such as stateful computations and modularity. Future research directions include further exploration of proof-theory-based semantics and expansion of the logic programming paradigms using known results from proof theory.

In summary, the paper posits that grounding logic programming in structural proof theory broadens its expressiveness and applicability, offering a pathway for more sophisticated and logically consistent programming languages. This foundational shift has marked significant developments in computer science and logic, influencing theorem proving, proof checking, and the paper of language semantics.