William E. Byrd

Pure, declarative, and constructive arithmetic relations (declarative pearl)

We present decidable logic programs for addition, multiplication, division with remainder, exponentiation, and logarithm with remainder over the unbounded domain of natural numbers. Our predicates represent relations without mode restrictions or annotations. They are fully decidable under the common, DFS-like, SLD resolution strategy of Prolog or under an interleaving refinement of DFS. We prove that the evaluation of our arithmetic goals always terminates, given arguments that share no logic variables. Further, the (possibly infinite) set of solutions for a goal denotes exactly the corresponding mathematical relation. (For SLD without interleaving, and for some infinite solution sets, only half of the relations domain may be covered.) We define predicates to handle unary (for illustration) and binary representations of natural numbers, and prove termination and completeness of these predicates. Our predicates are written in pure Prolog, without cut (!), var/1, or other nonlogical operators. The purity and minimalism of our approach allows us to declare arithmetic in other logic systems, such as Haskell type classes.

α lean TAP: A Declarative Theorem Prover for First-Order Classical Logic

We present α lean TA P , adeclarative tableau-based theorem prover written as a purerelation. Like lean TA P , on which it is based,α lean TA P can prove groundtheorems in first-order classical logic. Since it is declarative,α lean TA P generates theorems and accepts non-ground theorems and proofs. The lack ofmode restrictions also allows the user to provide guidance inproving complex theorems and to ask the prover to instantiatenon-ground parts of theorems. We present a complete implementationof α lean TA P , beginning with atranslation of lean TA P intoα Kanren, an embedding of nominal logic programmingin Scheme. We then show how to use a combination of tagging andnominal unification to eliminate the impure operators inheritedfrom lean TA P , resulting in a purely declarativetheorem prover.

A small embedding of logic programming with a simple complete search

We present a straightforward, call-by-value embedding of a small logic programming language with a simple complete search. We construct the entire language in 54 lines of Racket---half of which implement unification. We then layer over it, in 43 lines, a reconstruction of an existing logic programming language, miniKanren, and attest to our implementations pedagogical value. Evidence suggests our combination of expressiveness, concision, and elegance is compelling: since microKanrens release, it has spawned over 50 embeddings in over two dozen host languages, including Go, Haskell, Prolog and Smalltalk.

A unified approach to solving seven programming problems (functional pearl)

We present seven programming challenges in Racket, and an elegant, unified approach to solving them using constraint logic programming in miniKanren.

A simple complete search for logic programming

Here, we present a family of complete interleaving depth-first search strategies for embedded, domain-specific logic languages. We derive our search family from a stream-based implementation of incomplete depth-first search. The DSL’s programs’ texts induce particular strategies guaranteed to be complete. 1998 ACM Subject Classification D.3.2 Language Classifications: Applicative (functional) languages, Constraint and logic languages

Control-flow analysis of dynamic languages via pointer analysis

We demonstrate how to map a control-flow analysis for a higher-order language (dynamic languages are typically higher-order) into a pointer analysis for a first-order language, such as C. This allows us to use existing pointer analysis tools to perform a control-flow analysis, exploiting their technical advancements and the engineering effort that went into developing them. We compare the results of two recent parallel pointer analysis tools with a parallel control-flow analysis tool. While it has been known that a control-flow analysis of higher-order languages and a pointer analysis of first-order languages are very similar, we demonstrate that these two analyses are actually more similar than previously thought. We present the first mapping between a high-order control-flow analysis and a pointer analysis.

An Access Control Architecture for Distributing Trust in Pervasive Computing Environments

Pervasive computing infrastructure is highly distributed and it is essential to develop security mechanisms that enhance the security of the system by distributing trust among the various infrastructure components. We present a novel access control architecture explicitly designed to distribute trust that combines threshold cryptography, multi-layer encryption, and mediated access to contextual data to support dynamically changing access control permissions. We present several models of our access control infrastructure and evaluate how well each design distributes trust and limits the behavior of misbehaving components. We also simulate the behavior of our threshold based access control scheme and evaluate the overhead of each infrastructure model.