Logic-based Specification Research Articles

Separability and Its Approximations in Ontology-based Data Management

Given two datasets, i.e., two sets of tuples of constants, representing positive and negative examples, logical separability is the reasoning task of finding a formula in a certain target query language that separates them. As already pointed out in previous works, this task turns out to be relevant in several application scenarios such as concept learning and generating referring expressions. Besides, if we think of the input datasets of positive and negative examples as composed of tuples of constants classified, respectively, positively and negatively by a black-box model, then the separating formula can be used to provide global post-hoc explanations of such a model. In this paper, we study the separability task in the context of Ontology-based Data Management (OBDM), in which a domain ontology provides a high-level, logic-based specification of a domain of interest, semantically linked through suitable mapping assertions to the data source layer of an information system. Since a formula that properly separates (proper separation) two input datasets does not always exist, our first contribution is to propose (best) approximations of the proper separation, called (minimally) complete and (maximally) sound separations. We do this by presenting a general framework for separability in OBDM. Then, in a scenario that uses by far the most popular languages for the OBDM paradigm, our second contribution is a comprehensive study of three natural computational problems associated with the framework, namely Verification (check whether a given formula is a proper, complete, or sound separation of two given datasets), Existence (check whether a proper, or best approximated separation of two given datasets exists at all), and Computation (compute any proper, or any best approximated separation of two given datasets).

Logic-based specification and verification of homogeneous dynamic multi-agent systems

We develop a logic-based framework for formal specification and algorithmic verification of homogeneous and dynamic concurrent multi-agent transition systems. Homogeneity means that all agents have the same available actions at any given state and the actions have the same effects regardless of which agents perform them. The state transitions are therefore determined only by the vector of numbers of agents performing each action and are specified symbolically, by means of conditions on these numbers definable in Presburger arithmetic. The agents are divided into controllable (by the system supervisor/controller) and uncontrollable, representing the environment or adversary. Dynamicity means that the numbers of controllable and uncontrollable agents may vary throughout the system evolution, possibly at every transition. As a language for formal specification we use a suitably extended version of Alternating-time Temporal Logic, where one can specify properties of the type “a coalition of (at least) n controllable agents can ensure against (at most) m uncontrollable agents that any possible evolution of the system satisfies a given objective gamma″, where gamma is specified again as a formula of that language and each of n and m is either a fixed number or a variable that can be quantified over. We provide formal semantics to our logic {mathcal {L}}_{textsc {hdmas}} and define normal form of its formulae. We then prove that every formula in {mathcal {L}}_{textsc {hdmas}} is equivalent in the finite to one in a normal form and develop an algorithm for global model checking of formulae in normal form in finite HDMAS models, which invokes model checking truth of Presburger formulae. We establish worst case complexity estimates for the model checking algorithm and illustrate it on a running example.

More Effective Ontology Authoring with Test-Driven Development and the TDDonto2 Tool

Ontology authoring is a complex process, where commonly the automated reasoner is invoked for verification of newly introduced changes, therewith amounting to a time-consuming test-last approach. Test-Driven Development (TDD) for ontology authoring is a recent test-first approach that aims to reduce authoring time and increase authoring efficiency. Current TDD testing falls short on coverage of OWL features and possible test outcomes, the rigorous foundation thereof, and evaluations to ascertain its effectiveness. We aim to address these issues in one instantiation of TDD for ontology authoring. We first propose a succinct, logic-based specification of TDD testing and present novel TDD algorithms so as to cover also any OWL 2 class expression for the TBox and for the principal ABox assertions, and prove their correctness. The algorithms use methods from the OWL API directly such that reclassification is not necessary for test execution, therewith reducing ontology authoring time. The algorithms were implemented in TDDonto2, a Protégé plugin. TDDonto2 was evaluated by users, which demonstrated that modellers make significantly fewer errors with TDDonto2 compared to the standard Protégé interface and complete their tasks better using less time. Thus, the results indicate that TDD is a promising approach in an ontology development methodology.

AutoRELAX: automatically RELAXing a goal model to address uncertainty

Dynamically adaptive systems (DAS) must cope with system and environmental conditions that may not have been fully understood or anticipated during development. RELAX is a fuzzy logic-based specification language for identifying and assessing sources of environmental uncertainty, thereby making DAS requirements more tolerant of unanticipated conditions. This paper presents AutoRELAX, an approach that automatically generates RELAXed goal models to address environmental uncertainty. Specifically, AutoRELAX identifies goals to RELAX, which RELAX operators to apply, and the shape of the fuzzy logic function that establishes the goal satisfaction criteria. AutoRELAX generates different solutions by making tradeoffs between minimizing the number of RELAXed goals and maximizing delivered functionality by reducing the number of adaptations triggered by minor and adverse environmental conditions. In a recent extension, AutoRELAX uses a stepwise adaptation of weights to balance these two competing concerns and thereby further improve the utility of AutoRELAX. We apply it to two industry-based applications involving network management and a robotic controller, respectively.

Practical Aspects of Automated Deduction for Program Verification

Software is vital for modern society. It is used in many safety- or security-critical applications, where a high degree of correctness is desirable. Over the last years, technologies for the formal specification and verification of software—using logic-based specification languages and automated deduction—have matured and can be expected to complement and partly replace traditional software engineering methods in the future. Program verification is an increasingly important application area for automated deduction. The field has outgrown the area of academic case studies, and industry is showing serious interest. This article describes the aspects of automated deduction that are important for program verification in practise, and it gives an overview of the reasoning mechanisms, the methodology, and the architecture of modern program verification systems.

A Meta-model of Access Control in a Fibred Security Language

The issue of representing access control requirements continues to demand significant attention. The focus of researchers has traditionally been on developing particular access control models and policy specification languages for particular applications. However, this approach has resulted in an unnecessary surfeit of models and languages. In contrast, we describe a general access control model and a logic-based specification language from which both existing and novel access control models may be derived as particular cases and from which several approaches can be developed for domain-specific applications. We will argue that our general framework has a number of specific attractions and an implication of our work is to encourage a methodological shift from a study of the particulars of access control to its generalities.

Authority and Its Implementation in Enterprise Information Systems

The concept of power is inherent in human organizations of any type. As power relations have important consequences for organizational viability and productivity, they should be explicitly represented in enterprise information systems (EISs). Although organization theory provides a rich and very diverse theoretical basis on organizational power, still most of the definitions for power-related concepts are too abstract, often vague and ambiguous to be directly implemented in EISs. To create a bridge between informal organization theories and automated EISs, this article proposes a formal logic-based specification language for representing power (in particular authority) relations. The use of the language is illustrated by considering authority structures of organizations of different types. Moreover, the article demonstrates how the formalized authority relations can be integrated into an EIS.

Logic-based specification languages for intelligent software agents

The research field of Agent-Oriented Software Engineering (AOSE) aims to find abstractions, languages, methodologies and toolkits for modeling, verifying, validating and prototyping complex applications conceptualized as Multiagent Systems (MASs). A very lively research sub-field studies how formal methods can be used for AOSE. This paper presents a detailed survey of six logic-based executable agent specification languages that have been chosen for their potential to be integrated in our ARPEGGIO project, an open framework for specifying and prototyping a MAS. The six languages are $\textsf{ConGolog}$, $\textsf{AGENT-0}$, the $\textsf{IMPACT}$ agent programming language, $\textsf{DyLOG}$, Concurrent $\textsf{METATEM}$ and ${\cal E}_{hhf}$. For each executable language, the logic foundations are described and an example of use is shown. A comparison of the six languages and a survey of similar approaches complete the paper, together with considerations of the advantages of using logic-based languages in MAS modeling and prototyping.

Fusing Cooperative Technical-Specification Knowledge Components

In this paper, the problem of fusing various logic-based technical specification knowledge components about a same physical device or process is investigated. It is shown that most standard logic approaches to beliefs and knowledge fusion are not relevant in this context since some rules should be merged even in the case of mutually consistent knowledge components. Accordingly, we discuss the various types of formulas that should be merged during a fusion process, in order to avoid necessary conditions for the absence of failure to become sufficient conditions. This transformation is then described formally. It can be performed as an efficient preprocessing step on the knowledge components to be fused. The properties of this transformation schema are then investigated from a semantical point of view. Finally, a series of subsumption tests are proposed, preventing conditions for the absence of failure from being overridden by subsumption.

Logical Approach to Capability-Based Rewriting in a Mediator for WebSources

A logic-based specification for Capability-Based Rewriting (CBR) in web query processing is presented. Within this approach it is shown how Semantic Query Optimization (SQO) can be used to improve the performance of a web query optimizer. Our approach allows for the characterization of different CBR tools and their properties in a uniform and generic manner. It also reveals important optimization opportunities (based on SQO) which are commonly ignored in existing CBR tools.

NP- SPEC: an executable specification language for solving all problems in NP

In this paper a logic-based specification language, called NP- SPEC, is presented. The language is obtained by extending DATALOG through allowing a limited use of some second-order predicates of predefined form. NP- SPEC programs specify solutions to problems in a very abstract and concise way, and are executable. In the present prototype they are compiled to PROLOG code, which is run to construct outputs. Second-order predicates of suitable form allow to limit the size of search spaces in order to obtain reasonably efficient construction of problem solutions. NP- SPEC expressive power is precisely characterized as to express exactly the problems in the class NP. The specification of several combinatorial problems in NP- SPEC is shown, and the efficiency of the generated programs is evaluated.

A Hybrid Parallel Execution Model for Logic Based Requirement Specifications (Invited Paper)

It is well known that undiscovered errors in a requirements specification is extremely expensive to be fixed when discovered in the software maintenance phase. Errors in the requirement phase can be reduced through the validation and verification of the requirements specification. Many logic-based requirements specification languages have been developed to achieve these goals. However, the execution and reasoning of a logic-based requirements specification can be very slow. An effective way to improve their performance is to execute and reason the logic-based requirements specification in parallel. In this paper, we present a hybrid model to facilitate the parallel execution of a logic-based requirements specification language. A logic-based specification is first applied by a data dependency analysis technique which can find all the mode combinations that exist within a specification clause. This mode information is used to support a novel hybrid parallel execution model, which combines both top-down and bottom-up evaluation strategies. This new execution model can find the failure in the deepest node of the search tree at the early stage of the evaluation, thus this new execution model can reduce the total number of nodes searched in the tree, the total processes needed to be generated, and the total communication channels needed in the search process. A simulator has been implemented to analyze the execution behavior of the new model. Experiments show significant improvement based on several criteria.

Incremental Verification of Architecture Specification Language for Real-Time Systems

The concept of software architecture has recently emerged as a new way to improve our ability to effectively construct large scale software systems. However, there is no formal architecture specification language available to model and analyze temporal properties of complex real-time systems. In this paper, an object-oriented logic-based architecture specification language for real-time systems is discussed. Representation of the temporal properties and timing constraints, and their integration with the language to model real-time concurrent systems is given. Architecture based specification languages enable the construction of large system architectures and provide a means of testing and validation. In general, checking the timing constraints of real-time systems is done by applying model checking to the constraint expressed as a formula in temporal logic. The complexity of such a formal method depends on the size of the representation of the system. It is possible that this size could increase exponentially when the system consists of several concurrently executing real-time processes. This means that the complexity of the algorithm will be exponential in the number of processes of the system and thus the size of the system becomes a limiting factor. Such a problem has been defined in the literature as "state explosion problem". We propose a method of incremental verification of architectural specifications for real-time systems. The method has a lower complexity in a sense that it does not work on the whole state space, but only on a subset of it that is relevant to the property to be verified.

Integrating semi-formal and formal software specification techniques

In this paper, we report on the integration of informal, semiformal and formal system specification techniques. We present a framework for system specification called TRADE, within which several well-known semiformal specification techniques are placed. TRADE is based on an analysis of structured and object-oriented requirements specification methods. In this paper, we combine TRADE with the logic-based specification language Albert II and show that this leads to a coherent formal and semiformal requirements specification. We illustrate our approach with examples taken from a large distributed telecommunication application case study, performed in the context of the Esprit project 2RARE.

A logic-based transformation system

In spite of advances in various transformation systems the transformation of a nonmonotonic-logic-based requirements specification into a procedural (imperative) language program has not been investigated. This paper presents a logic-based transformation system that can transform a nonmonotonic-logic-based specification, the Frame-and-Rule Oriented Requirement Specification Language (FRORL), into procedural language programs. We discuss how to handle nonmonotonic inheritance in FRORL and then establish a matrix-based data flow and dependency analysis mechanism to find all the possible data transformation paths in a logic-based specification. Using a newly developed algorithm, we can adjust the execution sequence of a logic-based specification so that the functions included in the logic-based specification can be represented by a sequential procedural language program.

Conceptual modelling-based design of object-oriented databases

The focus of this article is the transformation of conceptual data models (such as ER, NIAM and PSM) to object-oriented databases. This transformation is captured within the framework of a two-level architecture. Conceptual models are first mapped to abstract intermediate specifications, which are then transformed to database schemas in a given object-oriented database environment. This enables us to treat different target systems in a uniform way. As final implementation environments, we consider object-oriented as well as object-relational DBMSs, including the SQL3 and ODMG-93 standards. We do not reveal the specific details of these standards. Rather, we use intermediate representations expressed in F-logic, a logic-based abstract specification language for object-oriented systems. Several transformation alternatives are discussed in a formal context, resulting in a collection of design options.

Generating functional test cases in-the-large for time-critical systems from logic-based specifications

We address the problem of generating functional test cases for complex, highly structured time-critical systems starting from a modularized logic-based specification written in the TRIOR + language, an object-oriented extension of the temporal logic TRIO.First, we present methods for producing test cases for a TRIO + specification module, referring both to the internal, hidden, portion of the module and to its interface. Then, we discuss criteria to be used in the construction of test cases from a TRIO + specification based on its composing modules and the connections among their interfaces. We formally define the notions related to test case derivation from TRIO + modules and we introduce an executable language for describing a variety of strategies for constructing test cases for structured TRIO + specifications starting from (parts of) the test cases of the composing modules. This language can be the basis for the implementation of an interactive tool for the semiautomatic construction of functional test cases from complex time-critical systems starting from their TRIO + specification.

Comparing RTL and FNLOG- timing properties in real-time systems

The specification and verification of real-time systems is an important component in the reliable development of such systems. Formal techniques of specification and verification have the advantage of formal analysis and design, as well as the possibility of automating some of the processes. FNLOG is a logic-based specification language for real-time systems, which is based on first order predicate logic with arithmetic extended by quantified temporal operators. FNLOG semantics is based on an underlying statechart, and a sound and relatively complete proof system for FNLOG exists. This paper presents extensions to FNLOG, inspired by Real Time Logic (RTL), to facilitate the specification of periodic and sporadic properties of real-time systems.

A model parametric real-time logic

TRIO is a formal notation for the logic-based specification of real-time systems. In this paper the language and its straightforward model-theoretic semantics are briefly summarized. Then the need for assigning a consistent meaning to TRIO specifications is discussed, with reference to a variety of underlying time structures such as infinite-time structures (both dense and discrete) and finite-time structures. The main motivation is the ability to validate formal specifications. A solution to this problem is presented, which gives a new, model-parametric semantics to the language. An algorithm for constructively verifying the satisfiability of formulas in the decidable cases is defined, and several important temporal properties of specifications are characterized.

A knowledge-based system for Ada® software development

In this article, we present a knowledge-based system using the concept of knowledge representation and data abstraction to support Ada software development. This article uses logic-based specification with object-oriented features to facilitate Ada software development. The Ada source code will be obtained through knowledge-based transformation. This system includes a frame-and-rule-oriented requirements language (FRORL), a predominance/particular methodology, and a knowledge base. FRORL uses frame representations for object-oriented modeling, applies production rules for specifying actions and constraints of real world domains, and provides a set of abstract mechanisms for the practical description of abstract relations. The predominance/particular methodology is used to support Ada software developers in performing object-oriented modeling of application domains. The knowledge base provides rules for specification checking, prototype validation, and transformation of specifications into Ada code. A real problem is given to illustrate the system.