Results 1  10
of
13
Discovering Algebraic Specifications from Java Classes
 In ECOOP
, 2003
"... We present and evaluate an automatic tool for extracting algebraic specifications from Java classes. Our tool maps a Java class to an algebraic signature and then uses the signature to generate a large number of terms. The tool evaluates these terms and based on the results of the evaluation, it pro ..."
Abstract

Cited by 86 (4 self)
 Add to MetaCart
(Show Context)
We present and evaluate an automatic tool for extracting algebraic specifications from Java classes. Our tool maps a Java class to an algebraic signature and then uses the signature to generate a large number of terms. The tool evaluates these terms and based on the results of the evaluation, it proposes equations. Finally, the tool generalizes equations to axioms and eliminates many redundant axioms. Since our tool uses dynamic information, it is not guaranteed to be sound or complete. However, we manually inspected the axioms generated in our experiments and found them all to be correct.
The Heterogeneous Tool Set
 of Lecture Notes in Computer Science
, 2007
"... Abstract. Heterogeneous specification becomes more and more important because complex systems are often specified using multiple viewpoints, involving multiple formalisms. Moreover, a formal software development process may lead to a change of formalism during the development. However, current resea ..."
Abstract

Cited by 58 (31 self)
 Add to MetaCart
(Show Context)
Abstract. Heterogeneous specification becomes more and more important because complex systems are often specified using multiple viewpoints, involving multiple formalisms. Moreover, a formal software development process may lead to a change of formalism during the development. However, current research in integrated formal methods only deals with adhoc integrations of different formalisms. The heterogeneous tool set (Hets) is a parsing, static analysis and proof management tool combining various such tools for individual specification languages, thus providing a tool for heterogeneous multilogic specification. Hets is based on a graph of logics and languages (formalized as socalled institutions), their tools, and their translations. This provides a clean semantics of heterogeneous specification, as well as a corresponding proof calculus. For proof management, the calculus of development graphs (known from other largescale proof management systems) has been adapted to heterogeneous specification. Development graphs provide an overview of the (heterogeneous) specification module hierarchy and the current proof state, and thus may be used for monitoring the overall correctness of a heterogeneous development. 1
Reasoning with Nondeterministic Specifications
 Polish Academy of Sciences, Institute of CS
, 1995
"... this paper we concentrate on a specification language that can be of use in both cases. We present a sound and complete Gentzenstyle deduction system for a logic that can be best (though rather informally) described as first order logic with inclusion and a let construct binding variables in nondet ..."
Abstract

Cited by 7 (2 self)
 Add to MetaCart
this paper we concentrate on a specification language that can be of use in both cases. We present a sound and complete Gentzenstyle deduction system for a logic that can be best (though rather informally) described as first order logic with inclusion and a let construct binding variables in nondeterministic terms. We should also remark here that this paper presents a nontrivial firstorder extension of a calculus presented in [BK 95a]. It contains a detailed analysis of the phenomena related to empty carriers in multisorted environment. Also, we do not place any restrictions on the models, and allow for both empty carriers and partial functions. One may observe at this point that instead of multialgebras we might have used relational algebras. However, we prefer functions for the same reason that functions are present in first order logic  they are more intuitive in applications and have properties that make their use easier. Moreover, as it will be explained in the last section, we need "ordinary" algebras to be a special case of the formalism we develop.
FailStop Software Components by Pattern Matching
 Stanford University, USA
, 1999
"... We consider system design from preexisting components, providing the operations to generate, observe and modify their internal state. Showing that a component is faultfree requires us to carry out a proof of correctness with respect to its specification. A failstop component may instead not satis ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
(Show Context)
We consider system design from preexisting components, providing the operations to generate, observe and modify their internal state. Showing that a component is faultfree requires us to carry out a proof of correctness with respect to its specification. A failstop component may instead not satisfy its specification statically but detect any violation at runtime. In this paper we study how regular expressions can play the role of such specifications, suitable for runtime behavior checking. We build such expressions from the logical properties over the component's observer operations which must hold about the state of the component in different points of its recorded execution history. Such a specification can become part of an automatically generated wrapper which carries out runtime checking as a kind of "patternmatching". Tomasz Janowski is a Research Fellow of UNU/IIST. He received an MSc in Mathematics from the University of Gda'nsk (Poland) and a PhD in Computer Science fr...
Abstract Data Types in EventB  An Application of Generic Instantiation
, 2012
"... Abstract. Integrating formal methods into industrial practice is a challenging task. Often, different kinds of expertise are required within the same development. On the one hand, there are domain engineers who have specific knowledge of the system under development. On the other hand, there are fo ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
(Show Context)
Abstract. Integrating formal methods into industrial practice is a challenging task. Often, different kinds of expertise are required within the same development. On the one hand, there are domain engineers who have specific knowledge of the system under development. On the other hand, there are formal methods experts who have experience in rigorously specifying and reasoning about formal systems. Coordination between these groups is important for taking advantage of their expertise. In this paper, we describe our approach of using generic instantiation to facilitate this coordination. In particular, generic instantiation enables a separation of concerns between the different parties involved in developing formal systems. 1
A Categorical Approach to Logics and Logic Homomorphisms
, 2007
"... This master’s thesis presents a number of important concepts in logic such as models, entailment, and proof calculi within the framework of category theory. By describing these concepts as categories, a tremendous amount of generality and power is gained. In particular, this approach makes it possib ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
This master’s thesis presents a number of important concepts in logic such as models, entailment, and proof calculi within the framework of category theory. By describing these concepts as categories, a tremendous amount of generality and power is gained. In particular, this approach makes it possible to reason about maps from one logic to another in a consistent and convenient manner. By a consistent map is meant that the truth stays invariant, that is, a statement true in the source logic is mapped to a similarly true statement in the target logic. Conversely, a statement false in the source logic is mapped to a statement false in the target logic. While the thesis focuses on the theoretical notions outlined above, a brief coverage of two practical applications is given as a means to illustrate the utility of these notions. Concluding the text is a chapter containing a discussion and a section wherein possible future work is presented. In an effort to make the text mostly selfcontained, concepts beyond basic discrete mathematics are duly introduced with definitions and examples. These include, for
FailStop Softare Components by Pattern Matching
, 1999
"... We consider system design from preexisting components, providing the operations to generate, observe and modify their internal state. Showing that a component is faultfree requires us to carry out a proof of correctness with respect to its specification. A failstop component may instead not satis ..."
Abstract
 Add to MetaCart
We consider system design from preexisting components, providing the operations to generate, observe and modify their internal state. Showing that a component is faultfree requires us to carry out a proof of correctness with respect to its specification. A failstop component may instead not satisfy its specification statically but detect any violation at runtime. In this paper we study how regular expressions can play the role of such specifications, suitable for runtime behavior checking. We build such expressions from the logical properties over the component's observer operations which must hold about the state of the component in different points of its recorded execution history. Such a specification can become part of an automatically generated wrapper which carries out runtime checking as a kind of "patternmatching".
Refining algebraic data types
, 2006
"... Our purpose is to formalize two potential refinements of singlesorted algebraic data types – subalgebras and algebras which satisfy equivalence relations – by considering their categorical interpretation. We review the usual categorical formalization of single and multisorted algebraic data type ..."
Abstract
 Add to MetaCart
Our purpose is to formalize two potential refinements of singlesorted algebraic data types – subalgebras and algebras which satisfy equivalence relations – by considering their categorical interpretation. We review the usual categorical formalization of single and multisorted algebraic data types as initial algebras, and the correspondence between algebraic data types and endofunctors. We introduce a relation on endofunctors which corresponds to a subtyping relation on algebraic data types, and partially extend this relation to multisorted algebras. Finally, we explore how this relation can help us understand singlesorted algebraic data types which satisfy equivalence relations. 1 Algebraic Data Types as Initial Algebras In programming languages with type systems, a type usually represents a family of values, such as the space of 32bit integers: Int32 ∼ = Z/232Z. Some programming languages (popular examples include Haskell [Je99] and ML [MTHM97]) have type systems which allow a programmer to define her own families of values by means of a recursion equation. For example, the data type representing inductively constructed binary trees with integer values at the leaves can be defined by the equation IntTree = Int32 unionmulti (IntTree × IntTree). Typically, names must be assigned to the functions which allow the programmer to construct values of a data type. The diagram below illustrates this particular example:
Algebraic Semantics of DomainSpecific Languages
, 2006
"... 1.1 Algebra as a Specification Tool......................... 4 ..."
(Show Context)