We describe a Haskell [4, 6] prototype implementation of dynamo, a simple language for dynamic logic programming. 1 Dynamic Logic Programming Dynamic logic programming was introduced in Van Eijck [2]. This paper describes a first implementation of dynamo, a language for pure dynamic logic programming. The dynamo language implements the executable process interpretation of Dynamic Predicate Logic or DPL [3], augmented with constructs for bounded iteration and bounded choice, as described in [2]. The two main sources of inspiration for dynamo are DPL and Alma-0, a hybrid language for imperative programming mixed with logic programming developed by Apt c.s. [1]. The dynamo language demonstrates that dynamic interpretation of FOL can be used as guideline for dynamic logic programming. dynamo programs have a purely declarative dynamic semantics. There are no side effects, and no control features: dynamo is pure dynamic logic. Because of this logical purity, weakest precondition reasoning f...

. In Apt and Bezem [AB99] we provided a computational interpretation of first-order formulas over arbitrary interpretations. Here we complement this work by introducing a denotational semantics for first-order logic. Additionally, by allowing an assignment of a non-ground term to a variable we introduce in this framework logical variables. The semantics combines a number of well-known ideas from the areas of semantics of imperative programming languages and logic programming. In the resulting computational view conjunction corresponds to sequential composition, disjunction to "don't know" nondeterminism, existential quantification to declaration of a local variable, and negation to the "negation as finite failure" rule. The soundness result shows correctness of the semantics with respect to the notion of truth. The proof resembles in some aspects the proof of the soundness of the SLDNF-resolution. 1 Introduction Background To explain properly the motivation for the work ...

Dynamic First Order Logic (DFOL) results from interpreting quantification over a variable v as change of valuation over the v position, conjunction as sequential composition, disjunction as nondeterministic choice, and negation as (negated) test for continuation. We present a tableau style calculus for DFOL with explicit (simultaneous) binding, prove its soundness and completeness, and point out its relevance for programming with DFOL, for automated program analysis including loop invariant detection, and for semantics of natural language. Next, we extend this to an infinitary calculus for DFOL with iteration and connect up with other work in dynamic logic.

Ideally, in constraint programs, the solutions of problems are obtained by specifying their desired properties, whereas in imperative programs, the steps which lead to a solution must be defined explicitly, rather than being derived automatically. This paper deals with the design and implementation of the programming language Turtle, which integrates declarative constraints and imperative language elements in order to form a more powerful programming paradigm suitable for solving a wide range of problems.

Contents 1 Dynamic Logic Programming 2 2 Modelling Variable Assignment in Dynamo 3 3 Translating Dynamo into Standard FOL 3 4 Recursion in Dynamo 4 5 Decision Machines for Propositional Logic 5 6 Decision Machines for Modal Logic 8 7 Conclusion 9 1 1 Dynamic Logic Programming Dynamic logic programming is the result of making dynamic versions of rst order predicate logic executable. The main sources of inspiration for this are the dynamic variable binding strategies that have become fashionable in natural language analysis (DRT [8], Anaphora Logic [2], DPL [7]), the idea of implementing identity assertions as assignment commands familiar from constraint programming, and more in particular from Alma-0 [1], and the general injunction to explore logical dynamics emanating from the works of Johan van Benthem,, e.g. from [3]. The standard dynamic interpretation of FOL, where 9x is interpreted as the action of random assignment of a

The syntax and semantics of the programming language Alma-0 have been specified in the ASF+SDF formalism. This report contains the interesting parts of the specification, embedded in text explaining its structure, various technical details and the choices that have been made during the specification process. The report also contains a short introduction to the language Alma-0, including some examples of meaningful Alma-0-programs.

We provide here a computational interpretation of first-order logic based on a constructive interpretation of satisfiability w.r.t. a fixed but arbitrary interpretation. In this approach the formulas themselves are programs. This contrasts

The aim of the project is the design of a strongly typed constraint programming language that combines the advantages of logic and imperative programming. The first stage of the project was the design and implementation of Alma-0, a small programming language that provides a support for declarative programming within the imperative programming framework. It is obtained by extending a subset of Modula-2 by a small number of features inspired by the logic programming paradigm. In this paper we discuss the rationale for the design of Alma-0, the benefits of the resulting hybrid programming framework, and the current work on adding constraint processing capabilities to the language. In particular, we discuss the role of the logical and customary variables, the interaction between the constraint store and the program, and the need for lists.

Dynamic First Order Logic results from interpreting quantification over a variable v as change of valuation over the v position, conjunction as sequential composition, disjunction as nondeterministic choice, and negation as (negated) test for continuation. We present a tableau style calculus for DFOL with explicit (simultaneous) substitution, prove its soundness and completeness, and point out its relevance for programming with dynamic first order logic, and for automatic program analysis.

The paper gives a sketch of the executable process interpretation of first order logic that lies at the basis of the Dynamo programming language, and then takes on the task of improving its execution mechanism by means of constraint storage.