Algebraic Specification Research Articles

Automated reasoning for attributed graph properties

Graphs are ubiquitous in computer science. Moreover, in various application fields, graphs are equipped with attributes to express additional information such as names of entities or weights of relationships. Due to the pervasiveness of attributed graphs, it is highly important to have the means to express properties on attributed graphs to strengthen modeling capabilities and to enable analysis. Firstly, we introduce a new logic of attributed graph properties, where the graph part and attribution part are neatly separated. The graph part is equivalent to first-order logic on graphs as introduced by Courcelle. It employs graph morphisms to allow the specification of complex graph patterns. The attribution part is added to this graph part by reverting to the symbolic approach to graph attribution, where attributes are represented symbolically by variables whose possible values are specified by a set of constraints making use of algebraic specifications. Secondly, we extend our refutationally complete tableau-based reasoning method as well as our symbolic model generation approach for graph properties to attributed graph properties. Due to the new logic mentioned above, neatly separating the graph and attribution parts, and the categorical constructions employed only on a more abstract level, we can leave the graph part of the algorithms seemingly unchanged. For the integration of the attribution part into the algorithms, we use an oracle, allowing for flexible adoption of different available SMT solvers in the actual implementation. Finally, our automated reasoning approach for attributed graph properties is implemented in the tool AutoGraph integrating in particular the SMT solver Z3 for the attribute part of the properties. We motivate and illustrate our work with a particular application scenario on graph database query validation.

Behavioural and abstractor specifications revisited

In the area of algebraic specification there are two main approaches for defining observational abstraction: behavioural specifications use a notion of observational satisfaction for the axioms of a specification, whereas abstractor specifications define an abstraction from the standard semantics of a specification w.r.t. an observational equivalence relation between algebras. Earlier work by Bidoit, Hennicker, Wirsing has shown that in the case of first-order logic specifications both concepts coincide semantically under mild assumptions. Analogous results have been shown by Sannella and Hofmann for higher-order logic specifications and recently, by Hennicker and Madeira, for specifications of reactive systems using a dynamic logic with binders. In this paper, we bring these results into a common setting: we isolate a small set of characteristic principles to express the behaviour/abstractor equivalence and show that all three mentioned specification frameworks satisfy these principles and therefore their behaviour and abstractor specifications coincide semantically (under mild assumptions). As a new case we consider observational modal logic where observational satisfaction of Hennessy–Milner logic formulae is defined “up to” silent transitions and observational abstraction is defined by weak bisimulation. We show that in this case the behaviour/abstractor equivalence can only be obtained, if we restrict models to weakly deterministic labelled transition systems.

CoFI with Don Sannella

CoFI is the acronym of the Common Framework Initiative for Algebraic Specification and Development, which started in 1995. CoFI designed Casl, the Common Algebraic Specification Language.This article first summarises the origins of CoFI and the motivation for Casl. It then recalls some of the crucial contributions to CoFI made by Don Sannella, and concludes with an indication of the impact of CoFI.

ACP Semantics for Petri Nets

The paper deals with algebraic semantics for Petri nets, based on process algebra ACP. The semantics is defined by assigning a special variable to every place of given Petri net, expressing the process initiated in the place. Algebraic semantics of the Petri net is then defined as a parallel composition of all the variables, where corresponding places hold tokens within the initial marking. Resulting algebraic specification preserves operational behavior of the original net-based specification.

Improved Strongly Deniable Authenticated Key Exchanges for Secure Messaging

Abstract A deniable authenticated key exchange (DAKE) protocol establishes a secure channel without producing cryptographic evidence of communication. A DAKE offers strong deniability if transcripts provide no evidence even if long-term key material is compromised (offline deniability) and no outsider can obtain evidence even when interactively colluding with an insider (online deniability). Unfortunately, existing strongly deniable DAKEs have not been adopted by secure messaging tools due to security and deployability weaknesses. In this work, we propose three new strongly deniable key exchange protocols—DAKEZ, ZDH, and XZDH—that are designed to be used in modern secure messaging applications while eliminating the weaknesses of previous approaches. DAKEZ offers strong deniability in synchronous network environments, while ZDH and XZDH can be used to construct asynchronous secure messaging systems with offline and partial online deniability. DAKEZ and XZDH provide forward secrecy against active adversaries, and all three protocols can provide forward secrecy against future quantum adversaries while remaining classically secure if attacks against quantum-resistant cryptosystems are found. We seek to reduce barriers to adoption by describing our protocols from a practitioner’s perspective, including complete algebraic specifications, cryptographic primitive recommendations, and prototype implementations. We evaluate concrete instantiations of our DAKEs and show that they are the most efficient strongly deniable schemes; with all of our classical security guarantees, our exchanges require only 1 ms of CPU time on a typical desktop computer and at most 464 bytes of data transmission. Our constructions are nearly as efficient as key exchanges with weaker deniability, such as the ones used by the popular OTR and Signal protocols.

Enhancing Formal Methods Integration with ACP2Petri

The paper deals with the ACP2Petri tool, providing a transformation of process algebraic specification to equivalent Petri net-based specification. Long-term practical experiences with the tool revealed some suggestions for its update and extension. Shortcomings and limitations found are described and proposed solutions provided within the paper. Implemented extensions, simplifying the usage of the tool and providing more options for analysis of particular transformation, are also presented. One of the most evident extensions of the tool is its graphical user interface, which allows for convenient management and detailed control over the process of transformation.

Generating test case for algebraic specification based on Tabu search and genetic algorithm

To improve the effectiveness of generating test case for algebraic specification, an approach for generating test cases based on tabu search and genetic algorithm (Tabu GA) is presented. A prototype tool CASCATT (Common Algebraic Specification-based Class, Component and Web service Automatic Testing Tool) is implemented based on Tabu GA, which tests Class, Component and Web Service based on algebraic specification described by CASOCC-WS (Common Algebraic Specification of Components, Classes and Web service) language. The experiments results show the testing method is better effective, comparing with the existed random method in algebraic testing tool CASCAT (Common AS-based Component Automatic Testing) which generated test case from random data rewriting technology.

Formal analysis and verification support for reactive rule-based Web agents

Purpose Reactive rules are used for programming rule-based Web agents, which have the ability to detect events and respond to them automatically and can have complex structure and unpredictable behavior. The aim of this paper is to provide an appropriate formal framework for analyzing such rules. Design/methodology/approach To achieve this goal, the authors give two alternative semantics for the basic reactive rules’ families which allow us to specify reactive rule-based agents and verify their intended behavior. The first approach expresses the functionality of production and event condition action rules in terms of equations, whereas the second methodology is based in the formalism of rewriting logic. Both semantics can be expressed within the framework of CafeOBJ algebraic specification language, which then offers the verification support and have their advantages and downsides. Findings The authors report on experiences gained by applying those methodologies in a reactive rule-based system and compare the two methodologies. Originality/value Finally, the authors demonstrate a tool that translates a set of reactive rules into CafeOBJ rewrite rules, thus making the verification of reactive rules possible for inexperienced users.

Datatype defining rewrite systems for naturals and integers

A datatype defining rewrite system (DDRS) is an algebraic (equational) specification intended to specify a datatype. When interpreting the equations from left-to-right, a DDRS defines a term rewriting system that must be ground-complete. First we define two DDRSs for the ring of integers, each comprising twelve rewrite rules, and prove their ground-completeness. Then we introduce natural number and integer arithmetic specified according to unary view, that is, arithmetic based on a postfix unary append constructor (a form of tallying). Next we specify arithmetic based on two other views: binary and decimal notation. The binary and decimal view have as their characteristic that each normal form resembles common number notation, that is, either a digit, or a string of digits without leading zero, or the negated versions of the latter. Integer arithmetic in binary and decimal notation is based on (postfix) digit append functions. For each view we define a DDRS, and in each case the resulting datatype is a canonical term algebra that extends a corresponding canonical term algebra for natural numbers. Then, for each view, we consider an alternative DDRS based on tree constructors that yields comparable normal forms, which for that view admits expressions that are algorithmically more involved. For all DDRSs considered, ground-completeness is proven.

Towards formal open standards: formalizing a standard’s requirements

Open standardization seems to be very popular among software developers as it simplifies the standard's adoption by the software engineering. Formal specification methods, while very promising, are being adopted slowly as the industry seems to have little motivation to move into this territory. In this paper the authors present (1) the idea of applying formal specification techniques to open standards' specifications, and (2) an example of a formal specification of the Rich Site Summary (RSS) v2.0 open standard. The authors provide evidence for the advantages of the open standards formal specification over natural language documentations: formal specifications are more concise, less ambiguous, more complete with respect to the original documentation and, when using certain kinds of specification languages, executable and reusable as they support module inheritance. The merging of formal specification methods and open standards allows (1) a more concrete standard design; (2) an improved understanding of the environment under design; (3) an enforced certain level of precision into the specification, and also (4) provides software engineers with extended property checking/verification capabilities, especially if they opt to use any algebraic specification language. The authors showcase how the RSS standard can be formally specified using an algebraic specification language and demonstrate how can that be beneficial.

Verification of EB3 specifications using CADP

Abstract E B 3 is a specification language for information systems. The core of the E B 3 language consists of process algebraic specifications describing the behaviour of the entities in a system, and attribute function definitions describing the entity attributes. The verification of E B 3 specifications against temporal properties is of great interest to users of E B 3 . In this paper, we propose a translation from E B 3 to LOTOS NT (LNT for short), a value-passing concurrent language with classical process algebra features. Our translation ensures the one-to-one correspondence between states and transitions of the labelled transition systems corresponding to the E B 3 and LNT specifications. We automated this translation with the E B 3 2 L N T tool, thus equipping the E B 3 method with the functional verification features available in the CADP toolbox.

Exhaustive test sets for algebraic specifications

SummaryIn the context of testing from algebraic specifications, test cases are ground formulas chosen amongst the ground semantic consequences of the specification, according to some possible additional observability conditions. A test set is said to be exhaustive if every programme P passing all the tests is correct and if for every incorrect programme P, there exists a test case on which P fails. Because correctness can be proved by testing on such a test set, it is an appropriate basis for the selection of a test set of practical size. The largest candidate test set is the set of observable consequences of the specification. However, depending on the nature of specifications and programmes, this set is not necessarily exhaustive. In this paper, we study conditions to ensure the exhaustiveness property of this set for several algebraic formalisms (equational, conditional positive, quantifier free and with quantifiers) and several test hypotheses. Copyright © 2016 John Wiley & Sons, Ltd.

Kernels, in a nutshell

A classical result in algebraic specification states that a total function defined on an initial algebra is a homomorphism if and only if the kernel of that function is a congruence. We expand on the discussion of that result from an earlier paper: extending it from total to partial functions, simplifying the proofs using relational calculus, and generalising the setting to regular categories.

An Algebraic Framework for the Verification of Context-Aware Adaptive Systems

Context-aware and self adaptive systems have become very popular during the last decade. As these technologies are increasingly used in the development of critical applications, their behavior should be extensively analyzed. While formal methods provide a wide range of techniques for reasoning about software systems, addressing formally the requirements of context-aware adaptive systems in a consistent way remains a challenge. To this end, in this paper we present an algebraic framework for their formal specification using Observational Transition Systems (OTSs) specified in the CafeOBJ algebraic specification language. This approach permits the verification of the design of such systems, and can be an effective approach to obtaining verified context-aware software. We apply the proposed framework to the modeling of a context-aware adaptive traffic monitoring system and use theorem proving techniques to prove safety properties for that system.

Dynamic Programming on Nominal Graphs

Many optimization problems can be naturally represented as (hyper) graphs, where vertices correspond to variables and edges to tasks, whose cost depends on the values of the adjacent variables. Capitalizing on the structure of the graph, suitable dynamic programming strategies can select certain orders of evaluation of the variables which guarantee to reach both an optimal solution and a minimal size of the tables computed in the optimization process. In this paper we introduce a simple algebraic specification with parallel composition and restriction whose terms up to structural axioms are the graphs mentioned above. In addition, free (unrestricted) vertices are labelled with variables, and the specification includes operations of name permutation with finite support. We show a correspondence between the well-known tree decompositions of graphs and our terms. If an axiom of scope extension is dropped, several (hierarchical) terms actually correspond to the same graph. A suitable graphical structure can be found, corresponding to every hierarchical term. Evaluating such a graphical structure in some target algebra yields a dynamic programming strategy. If the target algebra satisfies the scope extension axiom, then the result does not depend on the particular structure, but only on the original graph. We apply our approach to the parking optimization problem developed in the ASCENS e-mobility case study, in collaboration with Volkswagen. Dynamic programming evaluations are particularly interesting for autonomic systems, where actual behavior often consists of propagating local knowledge to obtain global knowledge and getting it back for local decisions.

Algebraic Specification and Analysis of Health Records

Algebraic Specification and Analysis of Health Records

Implications of network topology on stability.

In analogy to chemical reaction networks, I demonstrate the utility of expressing the governing equations of an arbitrary dynamical system (interaction network) as sums of real functions (generalized reactions) multiplied by real scalars (generalized stoichiometries) for analysis of its stability. The reaction stoichiometries and first derivatives define the network’s “influence topology”, a signed directed bipartite graph. Parameter reduction of the influence topology permits simplified expression of the principal minors (sums of products of non-overlapping bipartite cycles) and Hurwitz determinants (sums of products of the principal minors or the bipartite cycles directly) for assessing the network’s steady state stability. Visualization of the Hurwitz determinants over the reduced parameters defines the network’s stability phase space, delimiting the range of its dynamics (specifically, the possible numbers of unstable roots at each steady state solution). Any further explicit algebraic specification of the network will project onto this stability phase space. Stability analysis via this hierarchical approach is demonstrated on classical networks from multiple fields.

Bisimulation proof methods in a path-based specification language for polynomial coalgebras

What reasoning rules can be used for the deduction of bisimulation formulas in coalgebraic specifications is problematic because those rules used in algebraic specifications possibly cannot be applied to bisimulation formulas. Although some categorical bisimulation proof methods for coalgebras have been proposed, they are not based on specification languages of coalgebras so that they cannot be used as reasoning rules. In this paper, a specification language based on paths of polynomial functors is proposed to specify polynomial coalgebras. Paths of polynomial functors give detailed observations and transitions on the state space of coalgebras so that the techniques used in transition system specifications can be applied to such a path-based language. In particular, because bisimulations can be characterized by paths, the notions of progressions, respectful functions and faithful contexts can be defined based on paths, and then bisimulation up-to proof techniques, including bisimulation up-to bisimilarities and up-to contexts for transition systems can be transformed into reasoning rules in the language. Several examples illustrate how to reason syntactically about bisimulations in the language by using the rules induced by the bisimulation proof techniques.

Specification of generic APIs, or

Specification based on Floyd-Hoare logic, using pre- and post-conditions, is common in languages aimed at high integrity software. Such pre/postcondition specifications are geared towards verification of code. While this specification technique has proven quite successful in the past 40 years, it has limitations when applied to API specification, particularly specification of generic interfaces. API-oriented design and genericity is of particular importance in modern large-scale software development. In this situation, algebraic specification techniques have a significant advantage. Unlike pre/post-based specification, which deals with the inputs and outputs of one operation at a time, algebraic specification deals with the relationships between the different operations in an API, which is needed in the specification of generic APIs.

Implementation of Abstract Data Types in Dynamic Sketches for Learning Geometry

A long-term observation of students’ usage of a dynamic geometry in a classroom at all grade levels has challenged to develop an approach for learning and understanding mathematics in an easier way for both students and teachers. The paper deals with the results of a study that investigates the process and outcomes of the implementation of abstract data types in dynamic sketches (by composing scripts) for learning geometry. Four abstract data types have been developed and defined using algebraic specifications. The development of a dynamic sketch scenario with the implementation of these abstract data types is presented in detail. An example of creating an interactive microworld, using abstract data types, is presented and discussed as well.