Rachid Echahed

A needed narrowing strategy

Narrowing is the operational principle of languages that integrate functional and logic programming. We propose a notion of a needed narrowing step that, for inductively sequential rewrite systems, extends the Huet and Le´vy notion of a needed reduction step. We define a strategy, based on this notion, that computes only needed narrowing steps. Our strategy is sound and complete for a large class of rewrite systems, is optimal w.r.t. the cost measure that counts the number of distinct steps of a derivation, computes only independent unifiers, and is efficiently implemented by pattern matching.

Design and Implementation of a Generic, Logic and Functional Programming Language

This paper presents the broad outlines of LPG, a language designed for generic specification and programming. In this language one may specify different modules which can represent either particular algebras (ADTs), families of algebras (generic data types and enrichments) or Σ-structures (theories). This language is based on Horn clause logic with equality which permits logic and functional programming to be combined. As modules in LPG can be generic, an instantiation mechanism is needed; such a mechanism is described here as well as the interpreter and an E-unification algorithm, thus making LPG a powerful programming language.

On the verification problem of nonregular properties for nonregular processes

Investigate the verification problem of infinite-state processes w.r.t. nonregular properties, i.e. nondefinable by finite-state /spl omega/-automata. We consider processes in the algebra PA (Process Algebra) which provides sequential and parallel (merge) composition, nondeterministic choice and recursion. The algebra PA integrates and strictly subsumes the algebras BPA (Basic Process Algebra, i.e. context-free processes) and BPP (Basic Parallel Processes). On the other hand, we consider properties definable in a new temporal logic called CLTL (Constrained Linear-Time Logic) which is an extension of the linear-time temporal logic LTL with two kinds of constraints on traces: constraints on the numbers of occurrences of states expressed using Presburger formulas (occurrence constraints), and constraints on the order of appearance of states expressed using finite-state automata (pattern constraints). Pattern constraints allow to capture all the /spl omega/-regular properties whereas occurrence constraints allow to define nonregular properties. Then, we present (un)decidability results concerning the verification problem for the different classes of processes mentioned above and different fragments of CLTL.

On the Automatic Verification of Systems with Continuous Variables and Unbounded Discrete Data Structures

We address the verification problem of invariance properties for hybrid systems. We consider as general models of hybrid systems finite automata, supplied with (unbounded) discrete data structures and continuous variables. We focus on the case of systems manipulating discrete counters and one pushdown stack, and on the other hand, constant slope continuous variables. The use of unbounded discrete data sturcture allows to consider systems with a powerful control, and to reason about important notions as the number of occurrences of events in some computation. The use of constant slope continuous variables allows to reason for instance about the time separating events and the durations of phases within some computation interval. We present decidability results for several subclasses of such models of hybrid systems; this provides automatic verification procedures for these systems.

Security policy in a declarative style

We address the problem of controlling information leakage in a concurrent declarative programming setting. Our aim is to define verification tools in order to distinguish between authorized, or declared, information flows such as password testing (e.g., ATM, login processes, etc.) and non-authorized ones. In this paper, we first propose a way to define security policies as confluent and terminating rewrite systems. Such policies define how the privacy levels of information evolve. Then, we provide a formal definition of secure processes with respect to a given security policy. We also define an actual verification algorithm of secure processes based on constraint solving.

Uniform Narrowing Strategies

In this paper we consider solution of equations in initial models, by using narrowing relationship. We introduce the notion of uniform narrowing strategies and prove the completeness of narrowing algorithms using such strategies. Then, we define the class of uniform specifications as specifications for which every narrowing strategy is uniform, and prove their decidability.

Inductively Sequential Term-Graph Rewrite Systems

Definitional trees have been introduced by Sergio Antoy in order to design an efficient term rewrite strategy which computes needed outermost redexes. In this paper, we consider the use of definitional trees in the context of term-graph rewriting. We show that, unlike the case of term rewrite systems, the strategies induced by definitional trees do not always compute needed redexes, in presence of term-graph rewrite systems. We then define a new class called inductively sequential term-graph rewrite systems (istGRS) for which needed redexes are still provided by definitional trees. Systems in this class are not confluent in general. We give additional syntactic criteria over istGRSs which ensure the confluence property with respect to the set of admissible term-graphs.

Verfying Invariance Properties of Timed Systems with Duration Variables

We consider the verification problem of invariance properties for timed systems modeled by (extended) Timed Graphs with duration variables. While clocks of a Timed Graph can be seen as continuous (real valued) variables with rates 1 at each control location of the system, duration variables (also called integrators) are continuous variables having rates 0 or 1. The use of integrators allows to reason about the accumulated delays spent at some particular locations during some computation. We show that under some conditions, the verification problem of invariance properties is decidable for (closed) Timed Graphs with one integrator, the integrator can be tested and/or reset at any transition. For this, we use a new digitization technique and prove that every real computation of such systems has a valid digitization. Then, we show how to solve the verification problem in the case of a discrete time domain.

Verifying infinite state processes with sequential and parallel composition

We investigate the verification problem of infinite-state process w.r.t. logic-based specifications that express properties which may be nonregular. We consider the process algebra PA which integrates and strictly subsumes the algebras BPA (basic process algebra) and BPP (basic parallel processes), by allowing both sequential and parallel compositions as well as nondeterministic choice and recursion. Many relevant properties of PA processes are nonregular, and thus can be expressed neither by classical temporal logics nor by finite state ω-automata. Properties of particular interest are those involving constraints on numbers of occurrences of events. In order to express such properties, which are nonregular in general, we use the temporal logic PCTL which combines the branching-time temporal logic CTL with Presburger arithmetics. Then we tackle the verification problem of guarded PA processes w.r.t. PCTL formulas. We mainly prove that, while this problem is undecidable for the full PCTL, it is actually decidable for the class of guarded PA processes (and thus for the class of guarded BPAs and guarded BPPs), and a large fragment of PCTL called PCTL+.

Combining Mobile Processes and Declarative Programming

We propose a general framework for combining mobile processes and declarative programming languages, e.g., functional, logic or functional-logic languages. In contrast to existing concurrent extensions of declarative languages, we distinguish clearly between the notion of processes and that of functions or predicates. Thus, our framework is generic and may be applied to extend several kinds of declarative languages. It also extends PA process algebra in order to deal with parameter passing, mobile processes and interactive declarative programming. In our setting, declarative programs are dynamic and may be modified thanks to the actions performed by processes.