Conformance Checking Research Articles

Knowledge capitalisation and organisation for conformance checking model in construction

This paper presents an ontological method aimed at the capitalisation and organisation of conformance-related knowledge for semi-automatic checking model of the conformance of construction projects against a set of conformance requirements. We start by developing a method for knowledge representation of explicit knowledge taking part in checking, and capitalisation of tacit knowledge defining checking practices. Then we explain our approach for classification, organisation and retrieval of conformance requirements and propose an approach for scheduling these requirements to optimise the checking process. Finally, we introduce our reasoning model that is based on matching graph representations of construction projects and conformance queries, and interpret the acquired results in terms of conformance checking in construction. To validate our approach, we describe a prototype illustrating its feasibility, and discuss ongoing works and perspectives of our research.

An ontology-based approach for formalisation and semantic organisation of conformance requirements in construction

This paper presents an ontology-based method for the formalisation and application of construction conformance requirements for effective code checking. This research continues our work on the development of a generic model automating the conformance checking of construction projects against building codes. We start from the analysis of the related research on the formalisation and organisation of building codes that allows us to formulate our approach for semantic annotation and scheduling of conformance requirements for conformance checking task. Our approach comprises 5 main steps: formalisation, semantic annotation, classification, context-based scheduling and semantic search of conformance requirements. They are implemented as corresponding key components of the C3R (Conformance Checking in Construction — Reasoning) prototype that we have developed to model the conformance checking process in construction. Finally, we discuss the ongoing work and perspectives of our research: the validation of our model by construction practices and the enrichment of our approach by usage-based knowledge.

Runtime Monitoring of Web Service Conversations

For a system of distributed processes, correctness can be ensured by (statically) checking whether their composition satisfies properties of interest. However, Web services are distributed processes that dynamically discover properties of other Web services. Since the overall system may not be available statically and since each business process is supposed to be relatively simple, we propose to use runtime monitoring of conversations between partners as a means of checking behavioral correctness of the entire Web service system. Specifically, we identify a subset of UML 2.0 sequence diagrams as a property specification language and show that it is sufficiently expressive for capturing safety and liveness properties. By transforming these diagrams to automata, we enable conformance checking of finite execution traces against the specification. We show how our language can be used to specify the specification property system (SPS). We describe an implementation of our approach as part of an industrial system. Finally, we discuss our experience of specifying and monitoring a number of properties from three existing applications.

Enforcing object protocols by combining static and runtime analysis

In this paper, we consider object protocols that constrain interactions between objects in a program. Several such protocols have been proposed in the literature. For many APIs (such as JDOM, JDBC), API designers constrain how API clients interact with API objects. In practice, API clients violate such constraints, as evidenced by postings in discussion forums for these APIs. Thus, it is important that API designers specify constraints using appropriate object protocols and enforce them. The goal of an object protocol is expressed as a protocol invariant. Fundamental properties such as ownership can be expressed as protocol invariants. We present a language, PROLANG, to specify object protocols along with their protocol invariants, and a tool, INVCOP++, to check if a program satisfies a protocol invariant. INVCOP++ separates the problem of checking if a protocol satisfies its protocol invariant (called protocol correctness), from the problem of checking if a program conforms to a protocol (called program conformance). The former is solved using static analysis, and the latter using runtime analysis. Due to this separation (1) errors made in protocol design are detected at a higher level of abstraction, independent of the program's source code, and (2) performance of conformance checking is improved as protocol correctness has been verified statically. We present theoretical guarantees about the way we combine static and runtime analysis, and empirical evidence that our tool INVCOP++ finds usage errors in widely used APIs. We also show that statically checking protocol correctness greatly optimizes the overhead of checking program conformance, thus enabling API clients to test whether their programs use the API as intended by the API designer.

Conformance checking of service behavior

A service-oriented system is composed of independent software units, namely services, that interact with one another exclusively through message exchanges. The proper functioning of such system depends on whether or not each individual service behaves as the other services expect it to behave. Since services may be developed and operated independently, it is unrealistic to assume that this is always the case. This article addresses the problem of checking and quantifying how much the actual behavior of a service, as recorded in message logs, conforms to the expected behavior as specified in a process model. We consider the case where the expected behavior is defined using the BPEL industry standard (Business Process Execution Language for Web Services). BPEL process definitions are translated into Petri nets and Petri net-based conformance checking techniques are applied to derive two complementary indicators of conformance: fitness and appropriateness . The approach has been implemented in a toolset for business process analysis and mining, namely ProM, and has been tested in an environment comprising multiple Oracle BPEL servers.

A Framework for Establishing Formal Conformance between Object Models and Object-Oriented Programs

Conformance between structural models and their implementations are usually simplified in practice, restraining reasoning to simple mappings between modeling and implementation constructs. This is not appropriate to accommodate the usual freedom of implementation for abstract concepts. A more flexible conformance notion must be addressed by conformance checking tools and model-driven development. In this paper, we propose a formal framework for defining conformance relationships between structural object models and object-oriented programs. In our framework, a syntactic mapping between model and program elements must be provided, yielding a coupling relation, used in framework instantiations for specific conformance relationships. Additionally, as in practice some intermediate program states are not relevant to conformance, we include the notion of heaps of interest, encompassing the filtered stable states for a less strict conformance checking. The framework is applied for establishing a conformance relationship in a technique of model-driven refactoring of programs.

Conformance checking of processes based on monitoring real behavior

Many companies have adopted Process-aware Information Systems (PAIS) to support their business processes in some form. On the one hand these systems typically log events (e.g., in transaction logs or audit trails) related to the actual business process executions. On the other hand explicit process models describing how the business process should (or is expected to) be executed are frequently available. Together with the data recorded in the log, this situation raises the interesting question “Do the model and the log conform to each other?”. Conformance checking, also referred to as conformance analysis, aims at the detection of inconsistencies between a process model and its corresponding execution log, and their quantification by the formation of metrics. This paper proposes an incremental approach to check the conformance of a process model and an event log. First of all, the fitness between the log and the model is measured (i.e., “Does the observed process comply with the control flow specified by the process model?”). Second, the appropriateness of the model can be analyzed with respect to the log (i.e., “Does the model describe the observed process in a suitable way?”). Appropriateness can be evaluated from both a structural and a behavioral perspective. To operationalize the ideas presented in this paper a Conformance Checker has been implemented within the ProM framework, and it has been evaluated using artificial and real-life event logs.

Formal semantics and analysis of control flow in WS-BPEL

Web service composition refers to the creation of new (Web) services by combining functionalities provided by existing ones. A number of domain-specific languages for service composition have been proposed, with consensus being formed around a process-oriented language known as WS-BPEL (or BPEL). The kernel of BPEL consists of simple communication primitives that may be combined using control-flow constructs expressing sequence, branching, parallelism, synchronization, etc. We present a comprehensive and rigorously defined mapping of BPEL constructs onto Petri net structures, and use this for the analysis of various dynamic properties related to unreachable activities, conflicting messages, garbage collection, conformance checking, and deadlocks and lifelocks in interaction processes. We use a mapping onto Petri nets because this allows us to use existing theoretical results and analysis tools. Unlike approaches based on finite state machines, we do not need to construct the state space, and can use structural analysis (e.g., transition invariants) instead. We have implemented a tool that translates BPEL processes into Petri nets and then applies Petri-net-based analysis techniques. This tool has been tested on different examples, and has been used to answer a variety of questions.

Semantic interoperability in building design: Methods and tools

Semantic interoperability is a crucial element to make building information models understandable and model data sharable across multiple design disciplines and heterogeneous computer systems. This paper presents a new approach and its software implementation for the development of building design objects with semantics of interoperable information to support semantic interoperability in building designs. The novelty of the approach includes its incorporation of building design domain ontology, object-based CAD information modeling, and interoperability standard to make building information models and model data semantically interoperable. A set of methods are proposed to address the issues of object-based building information representation compliant with the Industrial Foundation Classes (IFC); extension of IFC models with the supplementary information; and semantic annotation of the interoperable and extensible information sets. The prototype implementation of these methods provides a set of Web-enabled software tools for effectively generating, managing, and reusing the semantically interoperable building objects in design applications of architectural CAD, structural analysis, and building code conformance checking.

Using SCL to specify and check design intent in source code

Software developers often fail to respect the intentions of designers due to missing or ignored documentation of design intent. SCL (Structural Constraint Language) addresses this problem by enabling designers to formalize and confirm compliance with design intent. The designer expresses his intent as constraints on the program model using the SCL language. The SCL conformance checking tool examines developer code to confirm that the code honors these constraints. This paper presents the design of the SCL language and its checker, a set of practical examples of applying SCL, and our experience with using it both in an industrial setting and on open-source software

Partial Order Reduction for Detecting Safety and Timing Failures of Timed Circuits

This paper proposes a partial order reduction algorithm for timed trace theoretic verification in order to detect both safety failures and timing failures of timed circuits efficiently. This algorithm is based on the framework of timed trace theoretic verification according to the original untimed trace theory. Consequently, its conformance checking supports hierarchical structure when verifying timed circuits. Experimenting with the STARI and DME circuits, the proposed approach shows its effectiveness.

PROQOS?Dynamic SLA Management in DiffServ Space Links

Several base elements for the provision of quality of service guarantees have been developed in the recent past. Of these, the Differentiated Services (DiffServ) architecture stands out as the most promising. In spite of this, various issues remain, especially when multidomain DiffServ services are concerned. In this case, some forms of distributed management of Service Level Agreements that allow the specification, exchange, enforcement and monitoring of quality of service data must be in place. Although, again, some isolated solutions exist for each of these problems, considerable effort is necessary to make them work together. The project presented in this paper tried to assess the feasibility of providing differentiated quality of service in satellite IP networks, by developing a dynamic Service Level Agreement management solution for an IP over Digital Video Broadcast Satellite system. The functionality of the implemented system comprises system configuration, dynamic SLA negotiation, QoS monitoring and metering, SLA conformance checking, and QoS reporting to customers.

OclType – A Type or Metatype ?

C-LAB, Paderborn UniversityFuerstenallee 1133102 Paderborn, GermanyAbstractWhile the type system proposed in the OCL Standard Library of the latest OCL2.0 proposal seems to be considerably stable by now, there are still some de cienciesin the de nition of operations for type casts and type conformance checks. Thisresults from the fact that the types de ned on the user-level are currently not wellrepresented in the OCL Standard Library.This article presents a new modeling approach to adequately capture these typesin the OCL Standard Library through the UML core concept called powertype. Thepowertype concept allows to model a metaelement on the architectural user levelM1. By this approach, we propose an enhanced structure of the OCL StandardLibrary that prescribes a controlled way for accessing the metalevel.Key words: OCL Standard Library, Powertype

Design knowledge modeling and software implementation for building code compliance checking

Design knowledge formalization and design information modeling are critical issues in the development of building design support systems such as automated building code checking systems. This paper presents an object-based building modeling approach and its J2EE (Java 2 Platform, Enterprise Edition) implementation in a distributed system to facilitate the automated online code-checking process. It examines the issues of object-based representation of code provisions Industry Foundation Class (IFC)-compliant object model for building designs; Java-based rule inference and IFC-based geometric reasoning; and software prototype implementation on the J2EE platform. Application scenarios and online services of the prototype demonstrate the effectiveness of the approach and the system for building design conformance checking in a distributed environment.

Runtime Conformance Checking of Objects Using Alloy

Object models are an important part of most object-oriented software development methodologies, where they play a central role during the specification and design phases. However, their usefulness is much more limited during the implementation phase. In this paper, we demonstrate how confidence in source code can be increased by using runtime conformance checking to analyze the code with respect to an object model. More precisely, we use the Alloy Analyzer, developed at MIT, to determine automatically whether the runtime state of a program at certain user-specified locations conforms to a given object model. The design, implementation and evaluation of a prototype runtime conformance checker for Java programs with respect to Alloy object models is described.

Characterization of general systematic form errors for circular features

Characterizing systematic form errors in manufactured parts is essential to generate meaningful feedback information for production process improvement, as well as to develop a reliable conformance checking method. A new iterative measurement data analysis method is presented in this paper to characterize general and significant systematic form errors in parts with circular features, with two mathematical models based on combinations of Fourier components. The method starts from the ideal circular geometry and progresses by adding the most weighted Fourier component into the current model. This iterative process first constructs the dominant model containing the dominant Fourier components in the unknown systematic form error through the partial F-ratio test. The process then goes further to construct the significant model by capturing the remaining significant Fourier components through randomness tests that include the serial correlation and chi-square tests of the fitted residuals. It has been demonstrated from the analysis of extensive simulated and experimental data that the present method is able to characterize a wide variety of systematic form errors. The effect of random form error on the reliability of the systematic form error characterization has been examined and found to depend on its relative magnitude with the systematic form error.

Least-square curve and surface localization for shape conformance checking

We evaluate the elementary excitations of both spin-singlet and spin-triplet paired crystalline phases of a two-dimensional system of electrons in a perpendicular magnetic field. We use the harmonic Hamiltonian derived from a truncation of the intercell interactions at dipolar terms and treat it within a circular-cell approximation. At this level the excitations are of two types, i.e. a discrete spectrum of localized vibrorotational modes and a continuum of dispersive magneto-oscillations. The eigenfunctions and eigenfrequencies of the intracell dynamics depend on a single parameter, which contains the electron density and the magnetic length, and are exhibited as functions of this parameter for various sets of values of the radial and angular-momentum quantum numbers. The propagating excitations describe collective oscillations of the centre of mass of the electron pairs and derive, as in the usual unpaired crystal phase, from the magnetic-field-induced shifts of plasmons and transverse phonons of the crystal in zero field. Several illustrations of their dispersion curves are given. Possible extensions of the theory to include anharmonicity and higher intercell couplings are briefly discussed.

Least-square curve and surface localization for shape conformance checking

Abstract Verification of shape conformance for free-form cures and surfaces is commonly achieved by minimizing the sum of square deviations between measured points and a nominal curve/surface, thereby solving an optimal parameter estimation (OPE) problem. Finding the optimal rigid body (ORB) transformation between the measured points and nominal surface, an important step in the OPE problem, traditionally has involved iteratively solving a nonlinear optimization problem in six variables. This paper demonstrates that the optimization problem in six variables may be reduced to solving four degree-two implicit equations in four variables, which can be regarded as an eigenvalue problem. This results in considerable savings in the number of computations. A thorough analysis of the savings in computations and several examples are presented.

Compiler and tool support for debugging object protocols

We describe an extension to the Java programming language that supports static conformance checking and dynamic debugging of object “protocols,” i.e., sequencing constraints on the order in which methods may be called. Our Java protocols have a statically checkable subset embedded in richer descriptions that can be checked at run time. The statically checkable subtype conformance relation is based on Nierstrasz' proposal for regular (finite-state) process types, and is also very close to the conformance relation for architectural connectors in the Wright architectural description language by Allen and Garlan. Richer sequencing properties, which cannot be expressed by regular types alone, can be specified and checked at run time by associating predicates with object states. We describe the language extensions and their rationale, and the design of tool support for static and dynamic checking and debugging.

Client/Server Framework for On-Line Building Code Checking

This paper outlines an integrated client/server framework for an automated code-checking system. Most previous studies have focused on the processing of design codes for conformance checking. In this work, the writers examine additional issues: the criteria of a building model, the representation of code provisions, the relevance of the provisions with respect to design components, and the encoding of component-based provisions. In this paper, the writers will demonstrate the integration of these issues in the framework in order to develop an effective system to analyze a design for code compliance.