William W. Wadge

Lucid, a nonprocedural language with iteration

Lucid is a formal system in which programs can be written and proofs of programs carried out. The proofs are particularly easy to follow and straightforward to produce because the statements in a Lucid program are simply axioms from which the proof proceeds by (almost) conventional logical reasoning, with the help of a few axioms and rules of inference for the special Lucid functions. As a programming language, Lucid is unconventional because, among other things, the order of statements is irrelevant and assignment statements are equations. Nevertheless, Lucid programs need not look much different than iterative programs in a conventional structured programming language using assignment and conditional statements and loops.

Lucid—A Formal System for Writing and Proving Programs

Lucid is both a programming language and a formal system for proving properties of Lucid programs. The programming language is unconventional in many ways, although programs are readily understood as using assignment statements and loops in a “structured” fashion. Semantically, an assignment statement is really an equation between “histories”, and a whole program is simply an unordered set of such equations.From these equations, properties of the program can be derived by straightforward mathematical reasoning, using the Lucid formal system. The rules of this system are mainly those of first order logic, together with extra axioms and rules for the special Lucid functions.This paper formally describes the syntax and semantics of programs, and justifies the axioms and rules of the formal system.

An Extensional Treatment of Dataflow Deadlock

We discuss deadlock in reference to a simple equation data-flow language, and devise a test (the cycle sum test) which is applied to the dependency graph of a Program we use Kahns extensional semantics of data-flow and give a purely extensional (non operational) proof that no program passing the cycle sum test can ever deadlock. The proof is based on the notions of size (length) and completeness in the domain of histories, and should extend to a much widen context.

A new approach to version control

A method for controlling versions of software and other hierarchically structured entities is presented. Using the variant structure principle, a particular version of an entire system is formed by combining the most relevant existing versions of the various components of the system. An algebraic version language that allows histories (numbered series), subversions (or variants), and joins is described. It is shown that the join operation is simply the lattice least upper bound and together with the variant structure principle, provides a systematic framework for recombining divergent variants. The utility of this approach is demonstrated using LEMUR, a programming environment for modular C programs, which was developed using itself. The ways in which this notion of versions is related to the possible world semantics of intensional logic are discussed. >

Minimum model semantics for logic programs with negation-as-failure

We give a purely model-theoretic characterization of the semantics of logic programs with negation-as-failure allowed in clause bodies. In our semantics, the meaning of a program is, as in the classical case, the unique <i>minimum</i> model in a program-independent ordering. We use an expanded truth domain that has an uncountable linearly ordered set of truth values between <i>False</i> (the minimum element) and <i>True</i> (the maximum), with a <i>Zero</i> element in the middle. The truth values below <i>Zero</i> are ordered like the countable ordinals. The values above <i>Zero</i> have exactly the reverse order. Negation is interpreted as reflection about <i>Zero</i> followed by a step towards <i>Zero</i>; the only truth value that remains unaffected by negation is <i>Zero</i>. We show that every program has a unique minimum model <i>M</i><inf>P</inf>, and that this model can be constructed with a <i>T</i><inf>P</inf> iteration which proceeds through the countable ordinals. Furthermore, we demonstrate that <i>M</i><inf>P</inf> can alternatively be obtained through a construction that generalizes the well-known model intersection theorem for classical logic programming. Finally, we show that by collapsing the true and false values of the infinite-valued model <i>M</i><inf>P</inf> to (the classical) <i>True</i> and <i>False</i>, we obtain a three-valued model identical to the well-founded one.

Towards a unified theory of intensional logic programming

Abstract Intensional Logic Programming is a new form of logic programming based on intensional logic and possible worlds semantics. Intensional logic allows us to use logic programming to specify nonterminating computations and to capture the dynamic aspects of certain problems in a natural and problem-oriented style. The meanings of formulas of an intensional first-order language are given according to intensional interpretations and to elements of a set of possible worlds. Neighborhood semantics is employed as an abstract formulation of the denotations of intensional operators. Then we investigate general properties of intensional operators such as universality, monotonicity, finitariness and conjunctivity. These properties are used as constraints on intensional logic programming systems. The model-theoretic and fixpoint semantics of intensional logic programs are developed in terms of least (minimum) intensional Herbrand models. We show in particular that our results apply to a number of intensional logic programming languages such as Chronolog proposed by Wadge and Templog by Abadi and Manna. We consider some elementary extensions to the theory and show that intensional logic program clauses can be used to define new intensional operators. Intensional logic programs with intensional operator definitions are regarded as metatheories.

A 3D spreadsheet based on intensional logic

A three-dimensional spreadsheet design based on intensional logic is proposed. Intensional logic is concerned with assertions and other expressions whose meaning depends on an implicit context. The intensional spreadsheet is a declarative spreadsheet with a simple formal semantics called intensional semantics. It is expected to be suitable for a wide range of applications and for various users, including those who have had conventional programming experience. As an example of using the intensional 3-D spreadsheet, the formalization of a systolic algorithm for matrix multiplication is considered.<<ETX>>

Data Types as Objects

In this paper we present a new approach to the semantics of data types, in which the types themselves are incorporated as elements in the domain of data objects. The approach allows types to have subtypes, allows genuinely polymorphic functions, and gives a precise semantics for recursive type definitions (including definitions with parameters). In addition, the approach yields simple and straight forward methods for proving type properties of recursive definitions. These methods include a new fixedpoint rule which permits case analysis.

Higher-order functional languages and intensional logic

In this paper we demonstrate that a broad class of higher-order functional programs can be transformed into semantically equivalent multidimensional intensional programs that contain only nullary variable definitions. The proposed algorithm systematically eliminates user-defined functions from the source program, by appropriately introducing context manipulation (i.e. intensional) operators. The transformation takes place in M steps, where M is the order of the initial functional program. During each step the order of the program is reduced by one, and the final outcome of the algorithm is an M-dimensional intensional program of order zero. As the resulting intensional code can be executed in a purely tagged-dataflow way, the proposed approach offers a promising new technique for the implementation of higher-order functional languages.

Preferentially annotated regular path queries

In this paper, we introduce preferential regular path queries. These are regular path queries whose symbols are annotated with preference weights for “scaling” up or down the intrinsic importance of matching a symbol against a (semistructured) database edge label. Annotated regular path queries are expressed syntactically as annotated regular expressions. We interpret these expressions in a uniform semiring framework, which allows different semantics specializations for the same syntactic annotations. For our preference queries, we study three important aspects: (1) (progressive) query answering (2) (certain) query answering in LAV data-integration systems, and (3) query containment and equivalence. In all of these, we obtain important positive results, which encourage the use of our preference framework for enhanced querying of semistructured databases.