1.1 Quantification and the subformula property.................. 3 1.2 Ground forward sequent calculus......................... 5 1.3 Lifting to free variables............................... 10

Variable binding is a prevalent feature of the syntax and proof theory of many logical systems. In this paper, we define a programming language that provides intrinsic support for both representing and computing with binding. This language is extracted as the Curry-Howard interpretation of a focused sequent calculus with two kinds of implication, of opposite polarity. The representational arrow extends systems of definitional reflection with a notion of scoped inference rules, which are used to represent binding. On the other hand, the usual computational arrow classifies recursive functions defined by pattern-matching. Unlike many previous approaches, both kinds of implication are connectives in a single logic, which serves as a rich logical framework capable of representing inference rules that mix binding and computation. 1

We present a generalization of the ideal model for recursive polymorphic types. Types are defined as sets of terms instead of sets of elements of a semantic domain. Our proof of the existence of types (computed by fixpoint of a typing operator) does not rely on metric properties, but on the fact that the identity is the limit of a sequence of projection terms. This establishes a connection with the work of Pitts on relational properties of domains. This also suggests that ideals are better understood as closed sets of terms defined by orthogonality with respect to a set of contexts.

Most type systems are agnostic regarding the evaluation strategy for the underlying languages, with the value restriction for ML which is absent in Haskell as a notable exception. As type systems become more precise, however, detailed properties of the operational semantics may become visible because properties captured by the types may be sound under one strategy but not the other. For example, intersection types distinguish between call-by-name and call-by-value functions, because the subtyping law (A → B) ∩ (A → C) ≤ A → (B ∩ C) is unsound for the latter in the presence of effects. In this paper we develop a proof-theoretic framework for analyzing the interaction of types with evaluation order, based on the notion of polarity. Polarity was discovered through linear logic, but we propose a fresh origin in Dummett’s program of justifying the logical laws through alternative verificationist or pragmatist “meaning-theories”, which include a bias towards either introduction or elimination rules. We revisit Dummett’s analysis using the tools of Martin-Löf’s judgmental method, and then show how to extend it to a unified polarized logic, with Girard’s “shift ” connectives acting as intermediaries. This logic safely combines intuitionistic and dual intuitionistic reasoning principles, while simultaneously admitting a focusing interpretation for the classical sequent calculus. Then, by applying the Curry-Howard isomorphism to polarized logic, we obtain a single programming language in which evaluation order is reflected at the level of types. Different logical notions correspond directly to natural programming constructs, such as pattern-matching, explicit substitutions, values and call-by-value continuations. We give examples demonstrating the expressiveness of the language and type system, and prove a basic but modular type safety result. We conclude with a brief discussion of extensions to the language with additional effects and types, and sketch the sort of explanation this can provide for operationally-sensitive typing phenomena. 1

We define a dependent programming language in which programmers can define and compute with domain-specific logics, such as an access-control logic that statically prevents unauthorized access to controlled resources. Our language permits programmers to define logics using the LF logical framework, whose notion of binding and scope facilitates the representation of the consequence relation of a logic, and to compute with logics by writing functional programs over LF terms. These functional programs can be used to compute values at run-time, and also to compute types at compiletime. In previous work, we studied a simply-typed framework for representing and computing with variable binding [LICS 2008]. In this paper, we generalize our previous type theory to account for dependently typed inference rules, which are necessary to adequately represent domain-specific logics, and we present examples of using our type theory for certified software and mechanized metatheory.

While logic was once developed to serve philosophers and mathematicians, it is increasingly serving the varied needs of computer scientists. In fact, recent decades have witnessed the creation of the new discipline of Computational Logic. While Computation Logic can claim involvement in many, diverse areas of computing, little has been done to systematize the foundations of this new discipline. Here, we envision a unity for Computational Logic organized around recent developments in the theory of sequent calculus proofs. We outline how new tools and methodologies can be developed around a boarder approach to computational logic. Computational logic, unity of logic, proof theory 1. SOFTWARE AND HARDWARE CORRECTNESS IS CRITICALLY IMPORTANT Computer systems are everywhere in our societies and their integration with all parts of our lives is constantly increasing. There are a host of computer systems—such as those in cars, airplanes, missiles, hospital equipment—where correctness of software is

This paper is part of a line of work on using the logical techniques of polarity and focusing to design a dependent programming language, with particular emphasis on programming with deductive systems such as programming languages and proof theories. Polarity emphasizes the distinction between positive types, which classify data, and negative types, which classify computation. In previous work, we showed how to use Zeilberger’s higher-order formulation of focusing to integrate a positive function space for representing variable binding, an essential tool for specifying logical systems, with a standard negative computational function space. However, our previous work considers only a simply-typed language. The central technical contribution of the present paper is to extend higher-order focusing with a form of dependency that we call positively dependent types: We allow dependency on positive data, but not negative computation, and we present the syntax of dependent pair and function types using an iterated inductive definition, mapping positive data to types, which gives an account of type-level computation. We construct our language inside the dependently typed programming language Agda 2, making essential use of coinductive types and induction-recursion.

In this paper, we present a categorical model for Multiplicative Additive Polarized Linear Logic MALLP, which is the linear fragment (without structural rules) of Olivier Laurent’s Polarized Linear Logic. Our model is based on an adjunction between reflective/coreflective full subcategories C−/C+ of an ambient ∗-autonomous category C (with products). Similar structures were first introduced by M. Barr in the late 1970’s in abstract duality theory and more recently in work on game semantics for linear logic. The paper has two goals: to discuss concrete models and to present various completeness theorems. As concrete examples, we present (i) a hypercoherence model, using Ehrhard’s hereditary/anti-hereditary objects, (ii) a Chu-space model, (iii) a double gluing model over our categorical framework, and (iv) a model based on iterated double gluing over a ∗-autonomous category. For the multiplicative fragment MLLP of MALLP, we present both weakly full (Läuchli-style) as well as full completeness theorems, using a polarized version of functorial

monad, durnken logic, chemically assisted reasoning, alcohol in computer

The methodology by which deductive systems and metatheorems about them are encoded in the logical framework LF is well understood. Many (but not all) of these ideas have already been successfully extended to the case of encoding stateful deductive systems in the linear logical framework LLF. The main gap is the heretofore open question of whether one can bring to LLF the full power of relational metatheory as used with LF. This technique reduces the statement and proof of a wide class of theorems about deductive systems to the totality of certain typed, recursively defined relations, a property that can often be verified mechanically. The difficulty of making this technique work in the linear case comes from the lack of a sufficiently expressive language to capture invariants on how the context of linear hypotheses is manipulated. I claim that the gap can be closed by use of ideas from hybrid logic, an approach to temporal and modal logic that allows explicit reference to modal worlds. These ideas, when appropriately adapted to the setting of logical frameworks using linear logic, provide an elegant and predicative way of effectively quantifying over and manipulating linear contexts. I describe a hybrid logical framework HLF, a conservative extension of LLF in which one can encode precise formal theorems about stateful deductive systems. I propose as a thesis project that this language be used as the foundation of a system capable of mechanically checking proofs of these theorems. 1