This chapter introduces the sequent calculus as a formal system for constructing proofs and as a basis for automated proof search. It contrasts the book’s approach with Gentzen’s original formulation. The chapter details the different types of inference rules within the sequent calculus, including structural rules (weakening, contraction), identity rules (initial, cut), and introduction rules for logical connectives. It distinguishes between additive and multiplicative rules. Finally, it defines sequent calculus proofs as trees of inference rules and briefly touches upon the properties of cut elimination. Bibliographic notes point to relevant literature.

This chapter demonstrates how logic programming, particularly using linear logic, can be used to encode and reason about simple security protocols. It discusses specifying communication processes and protocols, including communication on a public network, static key distribution, and dynamic symbol creation. The chapter explores how to represent encrypted data as an abstract data type and model protocols as theories in linear logic. It also covers techniques for abstracting the internal states of agents and representing agents as nested implications. Bibliographic notes cite relevant work on formal methods for security protocol analysis.

This chapter introduces the idea that computation can be viewed and reasoned about through the lens of proof theory. It highlights the historical context of defining computation, noting the equivalence of formal systems like lambda-calculus and Turing machines. The chapter discusses the benefits of using logic to specify computations, emphasizing the universally accepted descriptions of logics, which can ensure the precision of meaning for logic programs. It also outlines the book’s structure, dividing it into two parts: the first covering the proof-theoretic foundations of logic programming languages, and the second exploring their applications. The chapter concludes with bibliographic notes.

This chapter presents sequent calculus proof systems for classical and intuitionistic logics, which are variations of Gentzen’s LK and LJ proof systems. It highlights the differences in their inference rules, particularly regarding the right-hand side of sequents. The chapter discusses the cut-elimination theorem for these logics and its significance. It also explores the increase in proof size that can result from eliminating cuts. Furthermore, the chapter considers the choices involved in proof search within these systems, distinguishing between don’t-know and don’t-care nondeterminism. Bibliographic notes direct the reader to relevant historical and contemporary works.

This chapter delves into the formal proof theory of linear logic focused proofs. It defines paths in linear logic formulas, using them to describe right-introduction and left-introduction phases. The chapter proves the admissibility of the non-atomic initial rule and demonstrates the elimination of cut rules in the focused system for linear logic. Finally, it establishes the completeness of the focused proof system with respect to the unfocused proof system for linear logic. Readers primarily interested in the applications of linear logic programming can skip this chapter.

This chapter explores how logic programs can exploit linear logic. It provides several examples of specifying computations using linear logic, such as computing on collections of natural numbers and organizing simple theorem provers. It also illustrates how conventional program tasks, such as reversing a list or generating all permutations of a list, can be achieved in novel ways using linear logic programs. The chapter also demonstrates an alternative approach to specifying sequent calculus proof systems as logic programs. Bibliographic notes offer further references to the specification of logic programs.

This chapter focuses on using logic programming to formalize the operational semantics of programming languages. It illustrates this with examples such as the call-by-value lambda calculus and the pi-calculus. The chapter discusses how to encode transition systems in sequent calculus and abstract machines as binary logic programs. It explores using linear logic to add side-effects to evaluation and specify concurrency primitives. Bibliographic notes direct the reader to relevant literature on formal semantics and logic-based approaches to language specification.

This chapter introduces two abstract logic programming languages, one based on first-order Horn clauses (fohc) and another on first-order hereditary Harrop formulas (fohh). It shows how these can be understood within the framework of uniform proofs in intuitionistic logic. The chapter discusses the limitations of these languages. It also explores the concept of focused proofs as a way to structure proof search. The chapter proves the completeness of focused proofs for a fragment of intuitionistic logic. Bibliographic notes provide references to related work in logic programming theory.

This chapter focuses on specifying computations using multisets within a logic programming framework. It illustrates this by encoding numerals, letters, and words as multisets. The chapter provides examples of encoding computational models such as finite automata and pushdown automata using linear logic and multisets. It also touches upon the properties of these encodings. Bibliographic notes point to related work on multiset rewriting and its applications.

This chapter lays the syntactic foundations for the book, covering topics in both first-order and higher-order logic. It introduces untyped lambda-terms and their properties, including beta-conversion and beta-normal forms. The chapter then defines types, signatures, and typed terms, restricting the typing judgment to beta-normal formulas. Finally, it introduces the concept of formulas and sequents, which are central to the proof-theoretic approach discussed in the book. Bibliographic notes provide references for further reading on these foundational concepts.

This chapter introduces higher-order quantification and its role in logic programming. It discusses the syntax and proof theory of higher-order quantification. The chapter explores the concept of near-focused proofs in the context of building proof systems for higher-order quantification. It builds upon the proof-theoretic foundations established in earlier chapters to extend the logic programming paradigms to the higher-order setting.