On the complexities of consistency checking for restricted UML class diagrams

Automatic debugging of UML class diagrams helps in the visual specification of software systems because users cannot detect errors in logical consistency easily. This study focuses on the tractable consistency checking of UML class diagrams. We accurately identify inconsistencies in these diagrams by translating them into first-order predicate logic that is generalized by counting quantifiers and classify their expressivities by eliminating certain components. We introduce optimized algorithms that compute the respective consistencies of class diagrams of different expressive powers in P, NP, PSPACE, or EXPTIME with respect to the size of the class diagrams. In particular, owing to the restrictions imposed on attribute value types, the complexities of consistency checking of class diagrams decrease from EXPTIME to P and PSPACE in two cases: (i) when the class diagrams contain disjointness constraints and overwriting/multiple inheritances and (ii) when the class diagrams contain both these components along with completeness constraints. Additionally, we confirm the existence of a restriction of class diagrams that prevents any logical inconsistency.     

Static consistency checking of web applications with WebDSL

Modern web application development frameworks provide web application developers with high-level abstractions to improve their productivity. However, their support for static verification of applications is limited. Inconsistencies in an application are often not detected statically, but appear as errors at run-time. The reports about these errors are often obscure and hard to trace back to the source of the inconsistency. A major part of this inadequate consistency checking can be traced back to the lack of linguistic integration of these frameworks. Parts of an application are defined with separate domain-specific languages, which are not checked for consistency with the rest of the application. Examples include regular expressions, query languages and XML-based languages for definition of user interfaces. We give an overview and analysis of typical problems arising in development with frameworks for web application development, with Ruby on Rails, Lift and Seam as representatives.To remedy these problems, in this paper, we argue that domain-specific languages should be designed from the ground up with static verification and cross-aspect consistency checking in mind, providing linguistic integration of domain-specific sub-languages. We show how this approach is applied in the design of WebDSL, a domain-specific language for web applications, by examining how its compiler detects inconsistencies not caught by web frameworks, providing accurate and clear error messages. Furthermore, we show how this consistency analysis can be expressed with a declarative rule-based approach using the Stratego transformation language.     

Visual and textual consistency checking tools for graphical userinterfaces

Designing user interfaces with consistent visual and textual properties is difficult. To demonstrate the harmful effects of inconsistency, we conducted an experiment with 60 subjects. Inconsistent interface terminology slowed user performance by 10 to 25 percent. Unfortunately, contemporary software tools provide only modest support for consistency control. Therefore, we developed SHERLOCK, a family of consistency analysis tools, which evaluates visual and textual properties of user interfaces. It provides graphical analysis tools such as a dialog box summary table that presents a compact overview of visual properties of all dialog boxes. SHERLOCK provides terminology analysis tools including an interface concordance, an interface spellchecker, and terminology baskets to check for inconsistent use of familiar groups of terms. Button analysis tools include a button concordance and a button layout table to detect variant capitalization, distinct typefaces, distinct colors, variant button sizes, and inconsistent button placements. We describe the design, software architecture, and the use of SHERLOCK. We tested SHERLOCK with four commercial prototypes. The outputs, analysis, and feedback from designers of the applications are presented     

Three way branching self consistency checking of hardware and software

A simple technique that improves a system's capability of error detection and correction, and enhances software debugging is described in this note. The technique relies on consistency checking of branching variables during branching decisions and the appropriate selection of codes for the permissible values of variables.     

Human,machines, and the interpretation of formal systems

There are plenty of intelligent machines in our world today: digital computers and autonomous robots. At the heart of each of these machines there are automatic formal systems (programs running on a digital computer). Now, if the interpretation of a formal system does not belong to the formal system itself, if the interpretation has to be added, it is worth asking: in the case of these intelligent machines that are massively interspersed in our social interactions, where does the interpretation come from? In this paper, we analyse what we call the invisibility of interpretation. Dealing with various types of formal systems (computers, robots, formalist approaches to Economics), the human source of the interpretation of these systems is sometimes concealed by a formalist restriction. To show how the formalist restriction produces the invisibility of interpretation allows us to underline our responsibility, as human agents, for all this interpretative work—and its importance for us as human beings.     

Automated formal verification of visual modeling languages by model checking

Graph transformation has recently become more and more popular as a general, rule-based visual specification paradigm to formally capture (a) requirements or behavior of user models (on the model-level), and (b) the operational semantics of modeling languages (on the meta-level) as demonstrated by benchmark applications around the Unified Modeling Language (UML). The current paper focuses on the model checking-based automated formal verification of graph transformation systems used either on the model-level or meta-level. We present a general translation that inputs (i) a metamodel of an arbitrary visual modeling language, (ii) a set of graph transformation rules that defines a formal operational semantics for the language, and (iii) an arbitrary well-formed model instance of the language and generates a transitions system (TS) that serve as the underlying mathematical specification formalism of various model checker tools. The main theoretical benefit of our approach is an optimization technique that projects only the dynamic parts of the graph transformation system into the target transition system, which results in a drastical reduction in the state space. The main practical benefit is the use of existing back-end model checker tools, which directly provides formal verification facilities (without additional efforts required to implement an analysis tool) for many practical applications captured in a very high-level visual notation. The practical feasibility of the approach is demonstrated by modeling and analyzing the well-known verification benchmark of dining philosophers both on the model and meta-level.     

The binary consistency checking scheme and its applications toseismic horizon detection

For a given set of n tuples, the binary consistency checking scheme generates a subset wherein no two elements intersect. The application of this scheme is illustrated by two problems in seismic horizon detection; seismic skeletonization and loop tying. After a brief introduction to seismic interpretation, these two examples are used to demonstrate how to cast an application problem into the formulism of the scheme. A comparison of this scheme to the dynamic programming approach to string matching due to S.Y. Lu (1982) is included     

Semantics of trace relations in requirements models for consistency checking and inferencing

Requirements traceability is the ability to relate requirements back to stakeholders and forward to corresponding design artifacts, code, and test cases. Although considerable research has been devoted to relating requirements in both forward and backward directions, less attention has been paid to relating requirements with other requirements. Relations between requirements influence a number of activities during software development such as consistency checking and change management. In most approaches and tools, there is a lack of precise definition of requirements relations. In this respect, deficient results may be produced. In this paper, we aim at formal definitions of the relation types in order to enable reasoning about requirements relations. We give a requirements metamodel with commonly used relation types. The semantics of the relations is provided with a formalization in first-order logic. We use the formalization for consistency checking of relations and for inferring new relations. A tool has been built to support both reasoning activities. We illustrate our approach in an example which shows that the formal semantics of relation types enables new relations to be inferred and contradicting relations in requirements documents to be determined. The application of requirements reasoning based on formal semantics resolves many of the deficiencies observed in other approaches. Our tool supports better understanding of dependencies between requirements.     

One application of real-valued interpretation of formal power series

We define two natural properties of context-free grammars. The first property generalizes linearity and the second property strengthens nonlinearity. A language generated by an unambiguous grammar of the first type is called the language with weak linear structure and a language generated by an unambiguous grammar of the second type is called the language with strong nonlinear structure. Our main theorem states that the family of unambiguous grammars generating languages with weak linear structure and the family of unambiguous grammars generating languages with strong nonlinear structure are effectively separable.     

On the definition of sequential consistency

The definition of sequential consistency is compared with an intuitive notion of correctness. That the definition is not strong enough is illustrated through a hypothetical memory system which is clearly incorrect, yet sequentially consistent. It is claimed that the reason for this is the absence of a relation between what actually happens (temporal order) and what seems to happen (logical order). A stronger version of sequential consistency is proposed.     

On the complexity of formal grammars

Summary The time and space complexity of the class of languages generated in linear time by context-sensitive grammars is investigated. Among other results it is shown that the membership question for languages in the class is NP-complete.This research was supported in part by the National Science Foundation under Grants DCR75-15945 and MCS77-11360     

On the composability of consistency conditions

This paper presents a formal framework, which is based on the notion of a serialization set, that enables to compose a set of consistency conditions into a more restrictive one. To exemplify the utility of this framework, a list of very basic consistency conditions is identified, and it is shown that various compositions of the basic conditions yield some of the most commonly used consistency conditions, such as sequential consistency, causal memory, and Pipelined RAM. The paper also lists several applications that can benefit from even weaker semantics than Pipelined RAM that can be expressed as a composition of a small subset of the basic conditions.     

A systematic literature review of cross-domain model consistency checking by model management tools

Objective The goal of this study is to identify gaps and challenges related to cross-domain model management focusing on consistency checking. Method We conducted a systematic literature review. We used the keyword-based search on Google Scholar, and we identified 618 potentially relevant studies; after applying inclusion and exclusion criteria, 96 papers were selected for further analysis. Results The main findings/contributions are: (i) a list of available tools used to support model management; (ii) 40% of the tools can provide consistency checking on models of different domains and 25% on models of the same domain, and 35% do not provide any consistency checking; (iii) available strategies to keep the consistency between models of different domains are not mature enough; (iv) most of the tools that provide consistency checking on models of different domains can only capture up to two inconsistency types; (v) the main challenges associated with tools that manage models on different domains are related to interoperability between tools and the consistency maintenance. Conclusion The results presented in this study can be used to guide new research on maintaining the consistency between models of different domains. Example of further research is to investigate how to capture the Behavioral and Refinement inconsistency types. This study also indicates that the tools should be improved in order to address, for example, more kinds of consistency check.

     

Using formal metamodels to check consistency of functional views in information systems specification

UML notations require adaptation for applications such as Information Systems (IS). Thus we have defined IS-UML. The purpose of this article is twofold. First, we propose an extension to this language to deal with functional aspects of IS. We use two views to specify IS transactions: the first one is defined as a combination of behavioural UML diagrams (collaboration and state diagrams), and the second one is based on the definition of specific classes of an extended class diagram. The final objective of the article is to consider consistency issues between the various diagrams of an IS-UML specification. In common with other UML languages, we use a metamodel to define IS-UML. We use class diagrams to summarize the metamodel structure and a formal language, B, for the full metamodel. This allows us to formally express consistency checks and mapping rules between specific metamodel concepts.     

On the formal semantics of IF-like logics

In classical logics, the meaning of a formula is invariant with respect to the renaming of bound variables. This property, normally taken for granted, has been shown not to hold in the case of Independence Friendly (IF) logics. In this paper we argue that this is not an inherent characteristic of these logics but a defect in the way in which the compositional semantics given by Hodges for the regular fragment was generalized to arbitrary formulas. We fix this by proposing an alternative formalization, based on a variation of the classical notion of valuation. Basic metatheoretical results are proven. We present these results for Hodges' slash logic (from which these can be easily transferred to other IF-like logics) and we also consider the flattening operator, for which we give novel game-theoretical semantics.     

On the consistency of cardinal direction constraints

We present a formal model for qualitative spatial reasoning with cardinal directions utilizing a co-ordinate system. Then, we study the problem of checking the consistency of a set of cardinal direction constraints. We introduce the first algorithm for this problem, prove its correctness and analyze its computational complexity. Utilizing the above algorithm, we prove that the consistency checking of a set of basic (i.e., non-disjunctive) cardinal direction constraints can be performed in O(n⁵) time. We also show that the consistency checking of a set of unrestricted (i.e., disjunctive and non-disjunctive) cardinal direction constraints is NP-complete. Finally, we briefly discuss an extension to the basic model and outline an algorithm for the consistency checking problem of this extension.     

On the consistency of hierarchical supervision in discrete-eventsystems

Hierarchical structure in the supervisory control of discrete-event systems is formalized in the automaton framework of P.J. Ramadge and W.M. Wonham (SIAM J. Cont. Optimiz., vol.25, no.1, p.206-30, 1987). The setup embodies a low-level real-world model controlled by an operator and a high-level abstract model virtually controlled by a manager. The two levels are connected by command and information channels. Concepts of hierarchical consistency are proposed, relating high-level behavior required by the manager to low-level behavior achievable by the operator. It is shown that consistency can be realized by appropriately refining the information sent up by the operator to the manager     

On behavioural pseudometrics and closure ordinals

A behavioural pseudometric is often defined as the least fixed point of a monotone function F on a complete lattice of 1-bounded pseudometrics. According to Tarski?s fixed point theorem, this least fixed point can be obtained by (possibly transfinite) iteration of F, starting from the least element ⊥ of the lattice. The smallest ordinal α such that $F^{\alpha }(\perp )=F^{\alpha +1}(\perp )$ is known as the closure ordinal of F. We prove that if F is also continuous with respect to the sup-norm, then its closure ordinal is ω. We also show that our result gives rise to simpler and modular proofs that the closure ordinal is ω.     

On stability of a formal concept

In this paper we define and analyze stability of a formal concept. A stability index is based on the idea of a dependency in a dataset that can be reconstructed from different parts of the dataset. This idea, underlying various methods of estimating scientific hypotheses, is used here for estimating concept-based hypotheses. Combinatorial properties of stability indices, algorithmic comlpexity of their computation, as well as their dynamics with arrival of new examples are studied. This work was supported by the project COMO (Concepts and Models) of the Deutsche Forschungsgemeinschaft (DFG) and Russian Foundation for Basic Research (RFBR).