Semi-formal Models Research Articles

A high order collaboration and real time formal model for automatic testing of safety critical systems

The need for safety critical systems (SCS) is both important and urgent, and their evaluation and verification are test-dependent. SCS are usually complex and very large, so manual testing of SCS are infeasible in practice, and developing automatic test approaches for SCS has become an important trend. This paper defines a formal semantics model for automatic test of SCS, called AutTMSCS, which describes behaviors in SCS testing. The model accommodates the high order collaboration in real time and temporariness of SCS testing. Testing tasks, test equipment and products under test are abstracted and architected in three layers, and a method for automatic testing is given. Based on extended label transition system (LTS), the convergency and correctness of the model are proved to demonstrate the computability of the model, indicating that the testing process of SCS can be automatic.

Formal Modeling and Analysis of Object Oriented Systems using Triple Graph Grammars

This paper proposes a Model Driven Engineering automatic translation approach based on the integration of rewriting logic formal specification and UML semi-formal models. This integration is a contribution in formalizing UML models since it lacks for formal semantics. It aims at providing UML with the capabilities of rewriting logic and its Maude language to control and detect incoherencies in their diagrams. Rewriting logic Maude language allows simulation and verification of system's properties using its LTL model-checker. This automatic translation approach is based on meta-modeling and graph transformation since UML diagrams are graphs. More precisely, the authors have proposed five meta-models and three triple graph grammars to perform the translation process. The authors have used Eclipse Generative Modeling tools: Eclipse Modeling Framework (EMF) for meta-modeling, Graphical Modeling Framework (GMF) for generating visual modeling tools and TGG Interpreter for proposing triple graph grammars. The approach is illustrated through an example.

Approximate Analyzing of Labeled Transition Systems

As the most important formal semantic model, labeled transition systems are widely used, which can describe the general concurrent systems or control systems without disturbance. However, under normal circumstance, transition systems are complex and difficult to use due to large amount of calculation and the state space explosion problems. In order to overcome these problems, approximate equivalent labeled transition systems are proposed by means of incomplete low-up matrix decomposition factorization. This technique can reduce the complexity of computation and calculate under the allowing errors. As for continuous-time linear systems, we develop a modeling method of approximated transition system based on the approximate solution of matrix, which provides a facility for approximately formal semantic modeling for linear systems and to effectively analyze errors. An example of application in the context of linear systems without disturbances is studied.

Towards a Semantic Model for Textual Entailment Annotation

We introduce a new formal semantic model for annotating textual entailments that describes restrictive, intersective, and appositive modification. The model contains a formally defined interpreted lexicon, which specifies the inventory of symbols and the supported semantic operators, and an informally defined annotation scheme that instructs annotators in which way to bind words and constructions from a given pair of premise and hypothesis to the interpreted lexicon. We explore the applicability of the proposed model to the Recognizing Textual Entailment (RTE) 1–4 corpora and describe a first-stage annotation scheme on which we based the manual annotation work. The constructions we annotated were found to occur in 80.65% of the entailments in RTE 1–4 and were annotated with cross-annotator agreement of 68% on average. The annotated parts of the RTE corpora are publicly available for further research.

The Natural Topology of English

A sociopolitical explanation is offerred as to why the conventional received wisdom about English grammar has persisted so long among teachers of English, despite its well-known inconsistencies. The natural topology of all natural languages is, like those of the strings of symbols in a formal logical or algebraic expression, comprised of relational operators and conceptual operands rather than of subject and predicate. Use of the toplogy in the teaching of English as a second language is illustrated and a possible start at a formal model of semantics is introduced.

Derivation of OWL Ontology from XML Documents by Formal Semantic Modeling

The extensible markup language (XML), a standard format of web information, has a clear syntax but unfortunately an ambiguous formal semantics, which results in being not used directly in semantic web applications. So it is tough job to reuse XML-based data intelligently in the semantic web. To address this problem, a new formal technique of obtaining ontology data automatically from XML documents is proposed. We provide the XML a semantical interpretation by developing a graph-based formal language, which then can be automatically mapped into web ontology language OWL with semantics preserved. The semantic validity and entailment problem are also concerned. The automatical mapping tool has also been developed.

Deadlock detection and recovery for component-based systems

Component-based development has gained a lot of attention in recent years. As a software development paradigm, it enhances reusability and reduces complexity but it also brings new challenges in reliability, especially the deadlock problem. In this paper, we present a dynamic probe (DP) strategy for the deadlock problem of component-based systems (CBS). First a formal semantic model is proposed to abstract the interaction among the components for analyzing the deadlock connections, and then the dynamic probe detection (DPD) algorithm is used to detect the deadlock loops. If deadlock connections are detected then the dynamic probe elimination (DPE) algorithm is used to evaluate the component reliability using several measurement indexes to find a component with reliability lower than the other components, and then replace it. Last, in comparison to related work, the results show that the proposed strategy can achieve both lower processing cost and higher reliability.

Usage and Impact of Model-Based User Authorization

Identity management projects are often a great challenge for organizations. This is not due to the technical complexity of these projects, but due to the fact that managing access to resources and services involves a deep understanding of organizational responsibilities, workflows, and processes. The presented approach aims at enabling domain experts to deal with that complexity without the support of external expertise. To accomplish this, the approach involves the organizational dimension of role engineering. The integration of the organizational layer is achieved by seamlessly integrating model data from process optimization projects. Conceptual models carry knowledge about the structure of an organization and its processes. The role engineering process is driven by the information in these models. The presented approach is not limited to the technical level and thus allows a high degree of automation. This research deals with – in addition to a practical illustration – a theoretical answer to the question whether it is even possible to integrate semi-formal models in an automated transformation process of transformation and requirements for such a process. The aim of this paper is to give a first positive answer to this question and to provide a way to automatically generate a useful setting for configuring identity management systems based on semi-formal models.

Formal Semantics, Compilation and Execution of the GALS Programming Language DSystemJ

The paper presents a programming language, DSystemJ, for dynamic distributed Globally Asynchronous Locally Synchronous (GALS) systems, its formal model of computation, formal syntax and semantics, its compilation and implementation. The language is aimed at dynamic distributed systems, which use socket based communication protocols for communicating between components. DSystemJ allows the creation and control at runtime of asynchronous processes called clock-domains, their mobility on a distributed execution platform, as well as the runtime reconfiguration of the system's functionality and topology. As DSystemJ is based on a GALS model of computation and has a formal semantics, it offers very safe mechanisms for implementation of distributed systems, as well as potential for their formal verification. The details and principles of its compilation, as well as its required runtime support are described. The runtime support is implemented in the SystemJ GALS language that can be considered as a static subset of DSystemJ.

Developing Reliable yet Flexible Software through If-Then Model Transformation Rules

Developing reliable yet flexible software is a hard problem. Although modeling methods enjoy a lot of advantages, the exclusive use of just one of them, in many cases, may not guarantee the development of reliable and flexible software. Formal modeling methods ensure reliability because they use a rigorous approach to software development. However, lack of knowledge and high cost practically force developers to use semi-formal methods instead. Semi-formal (visual) modeling methods, which are widely used in practical large-scale software development, are not good enough for reliable software development. This paper proposes a new approach to the development of reliable yet flexible software by transforming formal and semi-formal models into each other. In this way, the advantages of both methods are incorporated in to the software development process. The structured rules, proposed in this paper, transform formal and visual models into each other through the iterative and evolutionary process. The feasibility as well as the effectiveness of the proposed approach is demonstrated using the multi-lift system as a test case.

An Approach for Modeling Architectural Design Rules in UML and its Application to Embedded Software

Current techniques for modeling software architecture do not provide sufficient support for modeling architectural design rules. This is a problem in the context of model-driven development in which it is assumed that major design artifacts are represented as formal or semi-formal models. This article addresses this problem by presenting an approach to modeling architectural design rules in UML at the abstraction level of the meaning of the rules. The high abstraction level and the use of UML makes the rules both amenable to automation and easy to understand for both architects and developers, which is crucial to deployment in an organization. To provide a proof-of-concept, a tool was developed that validates a system model against the architectural rules in a separate UML model. To demonstrate the feasibility of the approach, the architectural design rules of an existing live industrial-strength system were modeled according to the approach.

A Formal Semantics for Ciset and Ciset Relation Operators

In this paper we present a formal model of semantics for newly introduced operators of cisets, ciset relations. The notion of alternate worlds is used to formalize the information content of a ciset and ciset relations. A ciset represents a collection of (regular) sets. Similarly, a ciset relation represents a collection of (regular) relations. Once this collection has been identified, any ciset relational operator can be applied on the collection of (regular) relations represented by ciset relations involved. This approach is computationally inefficient and is introduced solely to fully explain in a formal way, the semantics of newly introduced operators.

Correlating Formal Semantic Models of Reo Connectors: Connector Coloring and Constraint Automata

Over the past decades, coordination languages have emerged for the specification and implementation of interaction protocols for communicating software components. This class of languages includes Reo, a platform for compositional construction of connectors. In recent years, various formalisms for describing the behavior of Reo connectors have come to existence, each of them serving its own purpose. Naturally, questions about how these models relate to each other arise. From a theoretical point of view, answers to these questions provide us with better insight into the fundamentals of Reo, while from a more practical perspective, these answers broaden the applicability of Reo's development tools. In this paper, we address one of these questions: we investigate the equivalence between coloring models and constraint automata, the two most dominant and practically relevant semantic models of Reo. More specifically, we define operators that transform one model to the other (and vice versa), prove their correctness, and show that they distribute over composition. To ensure that the transformation operators map one-to-one (instead of many-to-one), we extend coloring models with data constraints. Though primarily a theoretical contribution, we sketch some potential applications of our results: the broadening of the applicability of existing tools for connector verification and animation.

High confidence embedded software design

Traditional design methodology is not suitable for high-confidence embedded software due to the lack of a formal semantic model for software analysis, automatic code generation, and often designed embedded software is hard to reuse. In order to automatically generate high-confidence and reusable embedded software, we propose a TLM-centric, platform-based, time-triggered and component-oriented method. We use this new method to generate the control software for a quadrotor helicopter.

Dynamic Slicing Research of UML Statechart Specifications

This paper extends the well-known technique of dynamic slicing to Statechart specifications of reactive systems. Statechart language extends state machines along hierarchy, concurrency and communication – resulting in a compact visual notation that allows engineers to structure and modularize system descriptions. Dynamic slicing is well known in the domain of sequential transformational programs and has been found to be useful in understanding, analysis and verification. The classical definition of dynamic slicing is unsuitable for Statechart specifications. In this paper, we firstly formally define a formal semantics model -- observable semantics, which is very suitable for dynamic slicing, because that it only describes outside observable behavior and conceals unobservable behavior of Statechart specifications, and it fully captures the run-time dependence relation among the state transitions in the Statechart specification. Then we propose a new notion of dynamic slicing that, in our opinion, is more natural for Statechart specifications. We formally define notions of dynamic slicing criterion, dynamic slice and minimal dynamic slice, and we also explain how to produce valid dynamic slicing criterion and propose a simple and practical approximation algorithm for minimal dynamic slice generation using observable semantics as an intermediate representation.

Annotated RDF

Real-world use of RDF requires the ability to transparently represent and explain metadata associated with RDF triples. For example, when RDF triples are extracted automatically by information extraction programs, there is a need to represent where the triples came from, what their temporal validity is, and how certain we are that the triple is correct. Today, there is no theoretically clean and practically scalable mechanism that spans these different needs - reification is the only solution propose to date, and its implementations have been ugly. In this paper, we present Annotated RDF (or aRDF for short) in which RDF triples are annotated by members of a partially ordered set (with bottom element) that can be selected in any way desired by the user. We present a formal declarative semantics (model theory) for annotated RDF and develop algorithms to check consistency of aRDF theories and to answer queries to aRDF theories. We show that annotated RDF supports users who need to think about the uncertainty, temporal aspects, and provenance of the RDF triples in an RDF database. We develop a prototype aRDF implementation and show that our algorithms work efficiently even on real world data sets containing over 10 million triples.

Constraints in conceptual modelling: outlining an approach to business-driven web service composition

With Service-Oriented Architectures (SOAs), companies are facing a paradigm shift towards services as the key unit of their enterprise architectures. An exploitation of the potential of SOA is up to the applicability of business models for a transformation into service compositions. However, several shortcomings prevent semi-formal models from being a suitable resource of an automated transformation process. Problems result from a multitude of modelling aims, objects and procedures. This paper provides a method for business-process-oriented SOA design. A modelling environment gives an overview of business requirements and allows appropriate assignment of services to the business functions at the same time.

Performance and energy consumption estimation for commercial off-the-shelf component system design

Nowadays, component-based embedded real- time systems have been used to improve the system development as well as to keep cost down through the reuse of embedded software applications. Besides, the use of semi-formal models has been widely adopted in the embedded real-time system component and system life cycle due to their friendly and intuitive notations. However, the ever more complex systems of today require modeling methods that allow early detection of potential problems in the initial phases of development. This paper presents the mapping process of UML state machine diagram into a time Petri net with energy constraints so as to estimate execution time and energy consumption in early phases of the embedded real-time component development life cycle. The estimates obtained from the model show that the proposed approach is indeed a good approximation to the respective measures obtained from the real hardware platform.

Semantic Process Modeling – Design and Implementation of an Ontology-based Representation of Business Processes

An extension of process modeling languages is designed which allows representing the semantics of model element labels which are formulated in natural language by using concepts of a formal ontology. This combination of semiformal models with formal ontologies will be characterized as semantic process modeling. The approach is exemplarily applied to the languages EPC (Event-driven Process Chain), BPMN (Business Process Modeling Notation) and OWL (Web Ontology Language) and is generalized by means of an information model. The proposed formalization of the semantics of individual model elements in conjunction with the usage of inference engines allows the improvement of query functionalities in modeling tools and enables new possibilities of model validation. The integration of the approach in the IT-based work environments of modelers is demonstrated by a system architecture and a prototypical implementation. Evidently, advantages in the areas of modeling, model management, IT-business alignment, and compliance can be achieved by the application of modeling tools augmented with semantic technologies.

Linking Model-Driven Development and Software Architecture: A Case Study

A basic premise of model driven development (MDD) is to capture all important design information in a set of formal or semi-formal models which are then automatically kept consistent by tools. The concept however is still relatively immature and there is little by way of empirically validated guidelines. In this paper we report on the use of MDD on a significant real-world project over several years. Our research found the MDD approach to be deficient in terms of modelling architectural design rules. Furthermore, the current body of literature does not offer a satisfactory solution as to how architectural design rules should be modelled. As a result developers have to rely on time-consuming and error-prone manual practices to keep a system consistent with its architecture. To realise the full benefits of MDD it is important to find ways of formalizing architectural design rules which then allow automatic enforcement of the architecture on the system model. Without this, architectural enforcement will remain a bottleneck in large MDD projects.