Abstract. Artifacts are entities characterized by data of interest (constituting the state of the artifact) in a given business application, and a lifecycle, which constrains the artifact’s possible evolutions. In this paper we study relational artifacts, where data are represented by a full fledged relational database, and the lifecycle is described by a temporal/dynamic formula expressed in µ-calculus. We then consider business processes, modeled as a set of condition/action rules, in which the execution of actions (aka tasks, or atomic services) results in new artifact states. We study conformance of such processes wrt the artifact lifecycle as well as verification of temporal/dynamic properties expressed in µ-calculus. Notice that such systems are infinite-state in general, hence undecidable. However, inspired by recent literature on database dependencies developed for data exchange, we present a natural restriction that makes such systems finite-state, and the above problems decidable. 1

Abstract. We give semantic foundations to abstract domains consisting in first order logic formulæ in a theory, as used in verification tools or methods using SMT-solvers or theorem provers. We exhibit conditions for a sound usage of such methods with respect to multi-interpreted semantics and extend their usage to automatic invariant generation by abstract interpretation. 1

Program slicing is an automated source code extraction technique that has been applied to a number of problems including testing, debugging, maintenance, reverse engineering, program comprehension, reuse and program integration. In all these applications the size of the slice is crucial; the smaller the better. It is known that statement minimal slices are not computable, but the question of dataflow minimal slicing has remained open since Weiser posed it in 1979. This paper proves that static slicing algorithms produce dataflow minimal end slices for programs which can be represented as schemas which are free and liberal. 1.

This report describes research done at the Artificial Intelligence Laboratory of the Massachusetts Institute o Technology. Support for the laboratory's artificial intelligence research is provided in part by the Advanced Research Projects Agency of the Department of Defense under Office of Naval Research contracts N00014-75-C- 0643 and N00014-75-C-0522

. We exhibit a sequence Sn (n # 0) of while program schemes, i. e., while programs without interpretation, with the property that the while nesting depth of Sn is n, and prove that any while program scheme which is scheme equivalent to Sn , i. e., equivalent for all interpretations over arbitrary domains, has while nesting depth at least n. This shows that the while nesting depth imposes a strict hierarchy (the while hierarchy) when programs are compared with respect to scheme equivalence and contrasts with Kleene's classical result that every program is equivalent to a program of while nesting depth 1 (when interpreted over a fixed domain with arithmetic on non--negative integers). Our proof is based on results from formal language theory; in particular, we make use of the notion of star height of regular languages. 1 Introduction When comparing programming languages, one often has a vague impression of one language being more powerful than another. However, a basic result of the ...

The statements in a program may be classified as "kernel statements " if they participate directly in the computation of some output and as "control statements " if they participate directly in deciding the control path at branch points. Two programs are kernel equivalent if they always execute identical sequences of kernel statements given the same inputs. Kernel equivalence is defined formally and is shown to be practically decidable in many cases by a procedure of trying test cases. The concept of program kernel may also be used as a basis for proving correctness of programs. Descriptive Terms

Abstract-State Machines have been introduced as “a computation model that is more powerful and more universal than standard computation models”, by Yuri Gurevich in 1985 ([Gur85]). ASM gained much attention as a specification method, in particular for the description of the semantics of programming languages, communication protocols, distributed algorithms, etc. Gurevich proved recently that a sequential algorithm must only meet a few, liberal requirements, to be representable as an ASM. We re-formulate Gurevich’s requirements for sequential algorithms, as well as the semantics of ASM-programs and the proof of his main theorem. A couple of examples support and explain intuition and motivation of ASM.

Several approaches to reverse and re-engineering are based upon program slicing. Unfortunately, for large systems, such as those which typically form the subject of reverse engineering activities, the space and time requirements of slicing can be a barrier to successful application. Faced with this problem, several authors have found it helpful to merge Control Flow Graph (CFG) nodes, thereby improving the space and time requirements of standard slicing algorithms. The node-merging process essentially creates a ‘coarser ’ version of the original CFG. This paper introduces a theory for defining Control Flow Graph node coarsening calculi. The theory formalizes properties of interest, when coarsening is used as a precursor to program slicing. The theory is illustrated with a case study of a coarsening calculus, which is proved to have the desired properties of sharpness and consistency. 1