Results 1  10
of
15
Towards A Formal Operational Semantics Of Uml Statechart Diagrams
, 1999
"... : Statechart Diagrams are a notation for describing behaviours in the framework of UML, the Unified Modeling Language of objectoriented systems. UML is a semiformal language, with a precisely defined syntax and static semantics but with an only informally specified dynamic semantics. UML Statec ..."
Abstract

Cited by 59 (10 self)
 Add to MetaCart
: Statechart Diagrams are a notation for describing behaviours in the framework of UML, the Unified Modeling Language of objectoriented systems. UML is a semiformal language, with a precisely defined syntax and static semantics but with an only informally specified dynamic semantics. UML Statechart Diagrams differ from classical statecharts, as defined by Harel, for which formalizations and results are available in the literature. This paper sets the basis for the development of a formal semantics for UML Statechart Diagrams based on Kripke structures. This forms the first step towards model checking of UML Statechart Diagrams. We follow the approach proposed by Mikk and others: we first map Statechart Diagrams to the intermediate format of extended hierarchical automata and then we define an operational semantics for these automata. We prove a number of properties of such semantics which reflect the design choices of UML Statechart Diagrams. # The work described in this paper has been performed in the context of the ESPRIT Project n. 27439  HIDE. y C.N.R., Ist. CNUCE, Pisa, Italy, d.latella@cnuce.cnr.it z Technical University of Budapest, Dept. of Measurement and Information Systems, Budapest, Hungary, majzik@mit.bme.hu. Partially supported by the CNRNATO Guest Fellowship Programme. x University of York, Dept. of Computing, York, United Kingdom, mieke@cs.york.ac.uk. Supported by the TACIT network under the European Union TMR Programme, Contract ERB FMRX CT97 0133.
Proving Theorems about LISP Functions
, 1975
"... Program verification is the idea that properties of programs can be precisely stated and proved in the mathematical sense. In this paper, some simple heuristics combining evaluation and mathematical induction are described, which the authors have implemented in a program that automatically proves a ..."
Abstract

Cited by 48 (2 self)
 Add to MetaCart
Program verification is the idea that properties of programs can be precisely stated and proved in the mathematical sense. In this paper, some simple heuristics combining evaluation and mathematical induction are described, which the authors have implemented in a program that automatically proves a wide variety of theorems about recursive LISP functions. The method the program uses to generate induction formulas is described at length. The theorems proved by the program include that REVERSE is its own inverse and that a particular SORT program is correct. A list of theorems proved by the program is given. key words and phrases: LISP, automatic theoremproving, structural induction, program verification cr categories: 3.64, 4.22, 5.21 1 Introduction We are concerned with proving theorems in a firstorder theory of lists, akin to the elementary theory of numbers. We use a subset of LISP as our language because recursive list processing functions are easy to write in LISP and because ...
R.: A coinduction rule for entailment of recursively defined properties
 In Stuckey, P.J., ed.: 14th CP. Volume 5202 of LNCS
, 2008
"... Abstract. Recursively defined properties are ubiquitous. We present a proof method for establishing entailment G  = H of such properties G and H over a set of common variables. The main contribution is a particular proof rule based intuitively upon the concept of coinduction. This rule allows the i ..."
Abstract

Cited by 8 (7 self)
 Add to MetaCart
Abstract. Recursively defined properties are ubiquitous. We present a proof method for establishing entailment G  = H of such properties G and H over a set of common variables. The main contribution is a particular proof rule based intuitively upon the concept of coinduction. This rule allows the inductive step of assuming that an entailment holds during the proof the entailment. In general, the proof method is based on an unfolding (and no folding) algorithm that reduces recursive definitions to a point where only constraint solving is necessary. The constraintbased proof obligation is then discharged with available solvers. The algorithm executes the proof by a searchbased method which automatically discovers the opportunity of applying induction instead of the user having to specify some induction schema, and which does not require any base case. 1
A case against the GOTO
 Proc. ACM Ann. Conf
, 1972
"... It has been proposed, by E. W. Dijkstra and others, that the $oto statement in programming language is a principal culprit in programs which are difficult to understand, modify, and debug. More correctly, the argument is that it is possible to use the sot 0 to synthesize program structures with th ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
It has been proposed, by E. W. Dijkstra and others, that the $oto statement in programming language is a principal culprit in programs which are difficult to understand, modify, and debug. More correctly, the argument is that it is possible to use the sot 0 to synthesize program structures with these undesirable properties. Not all uses of the $oto are to be considered harmful; however, it is further argued that the "good " uses of the $oto fall into one of a small number of specific cases which may be handled by specific language constructs. This paper summarizes the arguments in favor of eliminating the $oto statement and some of the theoretical and practical implications of the proposal.
Abstract Interpretation using Attribute Grammars
 Volume 461 of LNCS
, 1990
"... This paper deals with the correctness proofs of attribute grammars using methods from abstract interpretation. The technique will be described by defining a livevariable analysis for a small flowchart language and proving it correct with respect to a continuation style semantics. The proof techniq ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
This paper deals with the correctness proofs of attribute grammars using methods from abstract interpretation. The technique will be described by defining a livevariable analysis for a small flowchart language and proving it correct with respect to a continuation style semantics. The proof technique is based on fixpoint induction and introduces an extended class of attribute grammars as to express a standard semantics. 1
Actor induction and metaevaluation
 In ACM Symposium on Principles of Programming Languages
, 1973
"... “Programa should not only work, but they should appear to work as well.” PDPlX Dogma The PLANNER project ia continuing research in natural and effective means for embedding knowledge in procedures. In the course of this work we have succeeded in unifying the formaliam around one fundamental concept ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
“Programa should not only work, but they should appear to work as well.” PDPlX Dogma The PLANNER project ia continuing research in natural and effective means for embedding knowledge in procedures. In the course of this work we have succeeded in unifying the formaliam around one fundamental concept: the ACTOR. Intuitively, an ACTOR is an active agent which plays a role on cue ac”c~ding to a script. Data We use structures, the ACTOR metaphor to functions, semaphores, emphasize monitors, the inseparability ports, descriptions, of control
Logic Program Development Based on Typed, Moded Schemata and Data Types
 UNIVERSITY OF BRISTOL
, 1997
"... The main contribution of the thesis is to develop a comprehensive framework for developing logic programs using #ve program schemata and some basic data types, and to evaluate its suitability for developing sizable programs. The schemata are intended to capture design decisions made by a programmer ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
The main contribution of the thesis is to develop a comprehensive framework for developing logic programs using #ve program schemata and some basic data types, and to evaluate its suitability for developing sizable programs. The schemata are intended to capture design decisions made by a programmer during topdown re#nement of a predicate. The schemata are completely independent from the data types, and have associated types and modes. The method of construction is to start from an initial typed moded call, and proceed using precisely defined refinement operations until primitive data type operations are introduced. It is shown that the construction method produces programs that are polymorphic manysorted formulas, and that computations using the programs cannot result in type or mode errors. The framework is compared with previous schemabased program development methods from the literature, and we argue that this method is better suited to the developmentof nontrivial programs, and is more amenable to computerised support. The introduction of types and modes into schemata is a significant addition, not previously reported. An approach to program veri#cation is also introduced, in which the proof of correctness of a program is built from proof schemata corresponding to the program schemata used in the design of the program. Finally an implementation of the system is described and its use is illustrated on some sizable programs. The implementation incorporates a static analysis algorithm for checking the validity of the modes during the development of the program.