A Note on Identity and Higher Order Quantification

There are two well-known approaches to programming with names, binding, and equivalence up to consistent renaming: representing names and bindings as concrete identifiers in a first-order language (such as Prolog), or encoding names and bindings as variables and abstractions in a higher-order language (such as λProlog). However, both approaches have drawbacks: the former often involves stateful name-generation and requires manual definitions for α-equivalence and capture-avoiding substitution, and the latter is semantically very complicated, so reasoning about programs written using either approach can be very difficult. Gabbay and Pitts have developed a new approach to encoding abstract syntax with binding based on primitive operations of name-swapping and freshness. This paper presents αProlog, a logic programming language that uses this approach, along with several illustrative example programs and an operational semantics.

There appears to be a growing consensus, even if not unanimity, that standard predicative second-order logic is the appropriate logical medium for the representation of a nominalist theory of predication.* We agree that this is indeed the case and formulate in this paper a model-theoretic approach which justifies that claim.* Because it is model-theoretic, our approach differs from the truth-value semantics approach of Leblanc and Weaver. Amongst other reasons, we prefer our model-theoretic approach so as to accommodate those nominalists for whom the assumption that there are potentially as many names as there are individuals is not acceptable. The models involved in our semantics, moreover, are precisely the same models as are already involved in standard first-order logic. Assignments of values (drawn from the domain of a given model) to the individual variables are extended, however, to what, relative to a given first-order language, we call nominalistic assignments to the π-place predicate variables (for each positive integer ή) these assign first-order formulas (wffs) of the language in question, relative to the free occurrences of n distinct individual variables occurring in those wffs, to the H-place predicate variables. The satisfaction by such an assignment of a second-order wff in a model is then defined by a double recursion on the logical structure of the wff and on the number of nested predicate quantifiers occurring therein.

Preface. 1. Introduction: The Need for Multiple Paradigms. Domain Engineering and Multiple Paradigms. Design, Analysis, Domains, and Families: Term Definitions. Beyond Objects. Commonality and Variability Analysis. Software Families. Multi-Paradigm Design. Multi-Paradigm Development and Programming Language. Commonality Analysis: Perspectives. Summary. 2. Commonality Analysis. Commonality: The Essence of Abstraction. Priming Analysis: The Domain Vocabulary. Dimensions of Commonality and Commonality Categories. Examples of Commonality. Reviewing the Commonality Analysis. Commonality and Evolution. Summary. 3. Variability Analysis. Variability: The Spice of Life. The Commonality Base. Positive and Negative Variability. The Domain and Range of Variability. Binding Time. Defaults. Variability Tables. Some Variability Traps. Reviewing the Variability Analysis. Variability Dependency Graphs. Summary. 4. Application Domain Analysis. Analysis, Domain Analysis, and Beyond. Subdomains within a Domain Analysis. The Structure of a Subdomain. Analysis: The Big Picture. Summary. 5. Object-Oriented Analysis. About Paradigms and Objects. Object-Oriented Commonality Analysis. Summary. 6. Solution Domain Analysis. The Other Domain. The C++ Solution Domain: An Overview. Data. Overloading. Class Templates. Function Templates. Inheritance. Virtual Functions. Commonality Analysis and Polymorphism. Preprocessor Directives. Negative Variability. A Summary of the C++ Solution Domain: A Family Table. 7. Simple Mixing of Paradigms. Putting It All Together: An Overview of Multi-Paradigm Design. Activities of Multi-Paradigm Design. Example: A Simple Language Translator. Design, Not Analysis. Another Example: Automatic Differentiation. Outboard Paradigms. Management Issues. Summary. 8. Weaving Paradigms Together. Method and Design. Commonality Analysis: What Dimension of Commonality? Multiple Paradigms: Multiple Dimensions of Variability in One Set of Commonalities Codependent Domains. Design and Structure. Another Example: A Finite-State Machine. Pattern-Based Solution Strategies. Summary. 9. Augmenting the Solution Domain with Patterns. The Value of Idioms and Patterns. Commonality and Variability in Common Patterns. Patterns of Negative Variability. Multi-Paradigm Tools as a Patterns Adjunct. Summary. References. Index. 0201824671T04062001

A collecting interpretation of expressions is an interpretation of a program that allows one to answer questions of the sort: “What are all possible values to which an expression might evaluate during program execution?” Answering such questions in a denotational framework is akin to traditional data flow analysis and, when used in the context of abstract interpretation, allows one to infer properties that approximate the run-time behavior of expression evaluation. Exact collecting interpretations of expressions are developed for three abstract functional languages: a strict first-order language, a nonstrict first-order language, and a nonstrict higher order language (the full untyped lambda calculus with constants). It is argued that the method is simple (in particular, no powerdomains are needed), Natural (it captures the intuitive operational behavior of a cache), yet more expressive than existing methods (it is the first exact collecting interpretation for either nonstrict higher order languages). Correctness of the interpretations with respect to the standard semantics is shown via a generalization of the notion of strictness. It is further shown how to form abstractions of these exact interpretations, using as an example a collecting strictness analysis which yields compile-time information not previously captured by conventional strictness analyses.

By limiting the range of the predicate variables in a second-order language, one may obtain restricted versions of second-order logic such as weak second-order logic or definable subset logic. In this note, we provide an infinitary strongly complete axiomatization for several systems of this kind having the range of the predicate variables as a parameter. The completeness argument uses simple techniques from the theory of Boolean algebras. This article is dedicated to our friend John N. Crossley on the occasion of his 86th birthday.

In this thesis, we explore techniques for the development and verification of programs in a high-level, expressive, and safe programming language. Our programs can express problems over unbounded domains and over recursive and mutable data structures. We present an implementation language flexible enough to build interesting and useful systems. We mostly maintain a core shared language for the specifications and the implementation, with only a few extensions specific to expressing the specifications. Extensions of the core shared language include imperative features with state and side effects, which help when implementing efficient systems. Our language is a subset of the Scala programming language. Once verified, programs can be compiled and executed using the existing Scala tools. We present algorithms for verifying programs written in this language. We take a layer-based approach, where we reduce, at each step, the program to an equivalent program in a simpler language. We first purify functions by transforming away mutations into explicit return types in the functions' signatures. This step rewrites all mutations of data structures into cloning operations. We then translate local state into a purely functional code, hence eliminating all traces of imperative programming. The final language is a functional subset of Scala, on which we apply verification. We integrate our pipeline of translations into Leon, a verifier for Scala. We verify the core functional language by using an algorithm already developed inside Leon. The program is encoded into equivalent first-order logic formulas over a combination of theories and recursive functions. The formulas are eventually discharged to an external SMT solver. We extend this core language and the solving algorithm with support for both infinite-precision integers and bit-vectors. The algorithm takes into account the semantics gap between the two domains, and the programmer is ultimately responsible to use the proper type to represent the data. We build a reusable interface for SMT-LIB that enables us to swap solvers transparently in order to validate the formulas emitted by Leon. We experiment with writing solvers in Scala; they could offer both a better and safer integration with the rest of the system. We evaluate the cost of using a higher-order language to implement such solvers, traditionally written in C/C++. Finally, we experiment with the system by building fully working and verified applications. We rely on the intersection of many features including higher-order functions, mutable data structures, recursive functions, and nondeterministic environment dependencies, to build concise and verified applications.

We introduce a simple Role-based Trust-management language [Formula: see text] and a set-theoretic semantics for it. We also introduce credential graphs as a searchable representation of credentials in [Formula: see text] and prove that reachability in credential graphs is sound and complete with respect to the semantics of [Formula: see text]. Based on credential graphs, we give goal-directed algorithms to do credential chain discovery in [Formula: see text], both when credential storage is centralized and when credential storage is distributed. A goal-directed algorithm begins with an access-control query and searches for credentials relevant to the query, while avoiding considering the potentially very large number of credentials that are unrelated to the access-control decision at hand. This approach provides better expected-case performance than bottom-up algorithms. We show how our algorithms can be applied to SDSI 2.0 (the ‘SDSI’ part of SPKI/SDSI 2.0). Our goal-directed, distributed chain discovery algorithm finds and retrieves credentials as needed. We prove that the algorithm is correct by proving that the algorithm is sound and complete with respect to the credential graph composed of the credentials it retrieves, and that the algorithm retrieves all credentials that constitute a traversable chain. We further introduce a storage type system for [Formula: see text], which guarantees traversability of chains when credentials are well typed. This type system can also help improve search efficiency by guiding search in the right direction, making distributed chain discovery with large number of credentials feasible.

This paper presents a novel technique for type-guided worst-case input generation for functional programs. The technique builds on automatic amortized resource analysis (AARA), a type-based technique for deriving symbolic bounds on the resource usage of functions. Worst-case input generation is performed by an algorithm that takes as input a function, its resource-annotated type derivation in AARA, and a skeleton that describes the shape and size of the input that is to be generated. If successful, the algorithm fills in integers, booleans, and data structures to produce a value of the shape given by the skeleton. The soundness theorem states that the generated value exhibits the highest cost among all arguments of the functions that have the shape of the skeleton. This cost corresponds exactly to the worst-case bound that is established by the type derivation. In this way, a successful completion of the algorithm proves that the bound is tight for inputs of the given shape. Correspondingly, a relative completeness theorem is proved to show that the algorithm succeeds if and only if the derived worst-case bound is tight. The theorem is relative because it depends on a decision procedure for constraint solving. The technical development is presented for a simple first-order language with linear resource bounds. However, the technique scales to and has been implemented for Resource Aware ML, an implementation of AARA for a fragment of OCaml with higher-order functions, user-defined data types, and types for polynomial bounds. Experiments demonstrate that the technique works effectively and can derive worst-case inputs with hundreds of integers for sorting algorithms, operations on search trees, and insertions into hash tables.

We consider a class of formula equations in first-order logic, Horn formula equations, which are defined by a syntactic restriction on the occurrences of predicate variables. Horn formula equations play an important role in many applications in computer science. We state and prove a fixed-point theorem for Horn formula equations in first-order logic with a least fixed-point operator. Our fixed-point theorem is abstract in the sense that it applies to an abstract semantics which generalises standard semantics. We describe several corollaries of this fixed-point theorem in various areas of computational logic, ranging from the logical foundations of program verification to inductive theorem proving.