@inproceedings{517, abstract = {{In the Semantic (Web) Services area, services are considered black boxes with a semantic description of their interfaces as to allow for precise service selection and configuration. The semantic description is usually grounded on domain-specific concepts as modeled in ontologies. This accounts for types used in service signatures, but also predicates occurring in preconditions and effects of services. Ontologies, in particular those enhanced with rules, capture the knowledge of domain experts on properties of and relations between domain concepts. In this paper, we present a verification technique for service compositions which makes use of this domain knowledge. We consider a service composition to be an assembly of services of which we just know signatures, preconditions, and effects. We aim at proving that a composition satisfies a (user-defined) requirement, specified in terms of guaranteed preconditions and required postconditions. As an underlying verification engine we use an SMT solver. To take advantage of the domain knowledge (and often, to enable verification at all), the knowledge is fed into the solver in the form of sorts, uninterpreted functions and in particular assertions as to enhance the solver’s reasoning capabilities. Thereby, we allow for deductions within a domain previously unknown to the solver. We exemplify our technique on a case study from the area of water network optimization software.}}, author = {{Walther, Sven and Wehrheim, Heike}}, booktitle = {{Proceedings of the 18th IEEE International Conference on Engineering of Complex Computer Systems (ICECCS)}}, pages = {{24 -- 32 }}, title = {{{Knowledge-Based Verification of Service Compositions - An SMT approach}}}, doi = {{10.1109/ICECCS.2013.14}}, year = {{2013}}, } @article{3180, author = {{Travkin, Oleg and Wehrheim, Heike and Schellhorn, Gerhard}}, journal = {{{ECEASST}}}, title = {{{Proving Linearizability of Multiset with Local Proof Obligations}}}, year = {{2012}}, } @article{3181, author = {{Ruhroth, Thomas and Wehrheim, Heike}}, journal = {{Sci. Comput. Program.}}, number = {{3}}, pages = {{270----289}}, title = {{{Model evolution and refinement}}}, doi = {{10.1016/j.scico.2011.04.007}}, year = {{2012}}, } @inproceedings{3182, author = {{Schellhorn, Gerhard and Wehrheim, Heike and Derrick, John}}, booktitle = {{Computer Aided Verification - 24th International Conference, {CAV} 2012, Berkeley, CA, USA, July 7-13, 2012 Proceedings}}, editor = {{Madhusudan, P. and A. Seshia, Sanjit}}, pages = {{243----259}}, title = {{{How to Prove Algorithms Linearisable}}}, doi = {{10.1007/978-3-642-31424-7_21}}, year = {{2012}}, } @inproceedings{590, abstract = {{Predicate abstraction is an established technique for reducing the size of the state space during verification. In this paper, we extend predication abstraction with block-abstraction memoization (BAM), which exploits the fact that blocks are often executed several times in a program. The verification can thus benefit from caching the values of previous block analyses and reusing them upon next entry into a block. In addition to function bodies, BAM also performs well for nested loops. To further increase effectiveness, block memoization has been integrated with lazy abstraction adopting a lazy strategy for cache refinement. Together, this achieves significant performance increases: our tool (an implementation within the configurable program analysis framework CPAchecker) has won the Competition on Software Verification 2012 in the category “Overall”.}}, author = {{Wonisch, Daniel and Wehrheim, Heike}}, booktitle = {{Proceedings of the 14th International Conference on Formal Engineering Methods (ICFEM)}}, pages = {{332--347}}, title = {{{Predicate Analysis with Block-Abstraction Memoization}}}, doi = {{10.1007/978-3-642-34281-3_24}}, year = {{2012}}, } @inproceedings{608, abstract = {{Predicate abstraction is an established technique in software verification. It inherently includes an abstraction refinement loop successively adding predicates until the right level of abstraction is found. For concurrent systems, predicate abstraction can be combined with spotlight abstraction, further reducing the state space by abstracting away certain processes. Refinement then has to decide whether to add a new predicate or a new process. Selecting the right predicates and processes is a crucial task: The positive effect of abstraction may be compromised by unfavourable refinement decisions. Here we present a heuristic approach to abstraction refinement. The basis for a decision is a set of refinement candidates, derived by multiple counterexample-generation. Candidates are evaluated with respect to their influence on other components in the system. Experimental results show that our technique can significantly speed up verification as compared to a naive abstraction refinement.}}, author = {{Timm, Nils and Wehrheim, Heike and Czech, Mike}}, booktitle = {{Proceedings of the 14th International Conference on Formal Engineering Methods (ICFEM)}}, pages = {{348--363}}, title = {{{Heuristic-Guided Abstraction Refinement for Concurrent Systems}}}, doi = {{10.1007/978-3-642-34281-3_25}}, year = {{2012}}, } @inproceedings{627, abstract = {{Block Abstraction Memoization (ABM) is a technique in software model checking that exploits the modularity of programs during verification by caching. To this end, ABM records the results of block analyses and reuses them if possible when revisiting the same block again. In this paper we present an implementation of ABM into the predicate-analysis component of the software-verification framework CPAchecker. With our participation at the Competition on Software Verification we aim at providing evidence that ABM can not only substantially increase the efficiency of predicate analysis but also enables verification of a wider range of programs.}}, author = {{Wonisch, Daniel}}, booktitle = {{Proceedings of the 18th International Conference on Tools and Algorithms for the Construction and Analysis of Systems (TACAS)}}, pages = {{531--533}}, title = {{{Block Abstraction Memoization for CPAchecker}}}, doi = {{10.1007/978-3-642-28756-5_41}}, year = {{2012}}, } @inproceedings{565, abstract = {{In model-driven development of multi-layer systems (e.g. application, platform and infrastructure), each layer is usually described by separate models. When generating analysis models or code, these separate models rst of all need to be linked. Hence, existing model transformations for single layers cannot be simply re-used. In this paper, we present a modular approach to the transformation of multi-layer systems. It employs model weaving to dene the interconnections between models of dierent layers. The weaving models themselves are subject to model transformations: The result of transforming a weaving model constitutes a conguration for the models obtained by transforming single layers, thereby allowing for a re-use of existing model transformations. We exemplify our approach by the generation of analysis models for component-based software.}}, author = {{Besova, Galina and Walther, Sven and Wehrheim, Heike and Becker, Steffen}}, booktitle = {{Proceedings of the 15th International Conference on Model Driven Engineering Languages & Systems (MoDELS)}}, pages = {{776--792}}, title = {{{Weaving-based configuration and modular transformation of multi-layer systems}}}, doi = {{10.1007/978-3-642-33666-9_49}}, year = {{2012}}, } @article{3183, author = {{Schneider, Steve and Treharne, Helen and Wehrheim, Heike}}, journal = {{Electr. Notes Theor. Comput. Sci.}}, pages = {{69----80}}, title = {{{Bounded Retransmission in Event-B{\(\parallel\)}CSP: a Case Study}}}, doi = {{10.1016/j.entcs.2011.11.019}}, year = {{2011}}, } @article{3184, author = {{Derrick, John and Schellhorn, Gerhard and Wehrheim, Heike}}, journal = {{{ACM} Trans. Program. Lang. Syst.}}, number = {{1}}, pages = {{4:1----4:43}}, title = {{{Mechanically verified proof obligations for linearizability}}}, doi = {{10.1145/1889997.1890001}}, year = {{2011}}, }