IMT Institutional Repository: No conditions. Results ordered -Date Deposited. 2024-03-29T00:47:57ZEPrintshttp://eprints.imtlucca.it/images/logowhite.pnghttp://eprints.imtlucca.it/2013-10-14T08:31:48Z2013-10-14T08:31:48Zhttp://eprints.imtlucca.it/id/eprint/1619This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/16192013-10-14T08:31:48ZControlling Polyvariance for Specialization-based VerificationProgram specialization has been proposed as a means of improving constraint-based analysis of infinite state reactive systems. In particular, safety properties can be specified by constraint logic programs encoding (backward or forward) reachability algorithms. These programs are then transformed, before their use for checking safety, by specializing them with respect to the initial states (in the case of backward reachability) or with respect to the unsafe states (in the case of forward reachability). By using the specialized reachability programs, we can considerably increase the number of successful verifications. An important feature of specialization algorithms is the so called polyvariance, that is, the number of specialized variants of the same predicate that are introduced by specialization. Depending on this feature, the specialization time, the size of the specialized program, and the number of successful verifications may vary. We present a specialization framework which is more general than previous proposals and provides control on polyvariance. We demonstrate, through experiments on several infinite state reactive systems, that by a careful choice of the degree of polyvariance we can design specialization-based verification procedures that are both efficient and precise.Fabio FioravantiAlberto PettorossiMaurizio ProiettiValerio Sennivalerio.senni@imtlucca.it2013-10-14T08:29:30Z2014-01-21T13:19:07Zhttp://eprints.imtlucca.it/id/eprint/1832This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/18322013-10-14T08:29:30ZProving theorems by program transformationIn this paper we present an overview of the unfold/fold proof method, a method for proving theorems about programs, based on program transformation. As a metalanguage for specifying programs and program properties we adopt constraint logic programming (CLP), and we present a set of transformation rules (including the familiar unfolding and folding rules) which preserve the semantics of CLP programs. Then, we show how program transformation strategies can be used, similarly to theorem proving tactics, for guiding the application of the transformation rules and inferring the properties to be proved. We work out three examples: (i) the proof of predicate equivalences, applied to the verification of equality between CCS processes, (ii) the proof of first order formulas via an extension of the quantifier elimination method, and (iii) the proof of temporal properties of infinite state concurrent systems, by using a transformation strategy that performs program specialization.Fabio FioravantiAlberto PettorossiMaurizio ProiettiValerio Sennivalerio.senni@imtlucca.it2013-10-03T07:57:29Z2014-01-21T14:28:14Zhttp://eprints.imtlucca.it/id/eprint/1812This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/18122013-10-03T07:57:29ZEfficient Generation of Test Data Structures using Constraint Logic Programming and Program TransformationThe goal of Bounded-Exhaustive Testing (BET) is the automatic generation of all test cases satisfying a given invariant, within a given size bound. When the test cases have a complex structure, the development of
correct and efficient generators becomes a very challenging task. In this paper we use Constraint Logic Programming (CLP) to systematically develop generators of structurally complex test data structures.
We follow a declarative approach which allows us to separate the issue of (i) defining the test data structure in terms of its properties, from that of (ii) efficiently generating data structure instances. This separation helps establish the correctness of the developed test case generators. We rely on a symbolic representation and we take advantage of efficient search strategies provided by CLP systems for generating test instances.
Through a running example taken from the literature on BET, we illustrate our test generation framework and we show that CLP allows us to develop easily understandable and efficient test generators.
Additionally, we propose a program transformation technique whose goal is to make the evaluation of these CLP-based generators much more efficient and we demonstrate its effectiveness on a number of complex test data structures.Fabio FioravantiMaurizio ProiettiValerio Sennivalerio.senni@imtlucca.it2012-09-26T13:50:03Z2013-03-07T12:56:25Zhttp://eprints.imtlucca.it/id/eprint/1384This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/13842012-09-26T13:50:03ZReachability Analysis via Specialization of Constraint Logic ProgramsFabio FioravantiAlberto PettorossiMaurizio ProiettiValerio Sennivalerio.senni@imtlucca.it2012-09-18T14:38:17Z2013-03-07T12:56:25Zhttp://eprints.imtlucca.it/id/eprint/1361This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/13612012-09-18T14:38:17ZGeneralization Strategies for the Verification of Infinite State SystemsWe present a comparative evaluation of some generalization
strategies which are applied by a method for the automated verification of infinite state reactive systems. The verification method is based on (1) the specialization of the constraint logic program which encodes the system with respect to the initial state and the property to be verified, and (2) a bottom-up evaluation of the specialized program. The generalization strategies are used during the program specialization phase for controlling when and how to perform generalization. Selecting a good generalization strategy is not a trivial task because it must guarantee the
termination of the specialization phase itself, and it should be a good balance between precision and performance. Indeed, a coarse generalization strategy may prevent one to prove the properties of interest, while an unnecessarily precise strategy may lead to high verification times. We
perform an experimental evaluation of various generalization strategies on several infinite state systems and properties to be verified.Fabio FioravantiAlberto PettorossiMaurizio ProiettiValerio Sennivalerio.senni@imtlucca.it2012-09-18T13:23:48Z2013-03-07T12:56:25Zhttp://eprints.imtlucca.it/id/eprint/1358This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/13582012-09-18T13:23:48ZProgram Specialization for Verifying Infinite State Systems: An Experimental EvaluationWe address the problem of the automated verification of temporal properties of infinite state reactive systems. We present some improvements of a verification method based on the specialization of constraint logic programs (CLP). First, we reformulate the verification method as a two-phase procedure: (1) in the first phase a CLP specification of an infinite state system is specialized with respect to the initial state of the system and the temporal property to be verified, and (2) in the second phase the specialized program is evaluated by using a bottom-up strategy. In this paper we propose some new strategies for performing program specialization during the first phase. We evaluate the effectiveness of these new strategies, as well as that of some old strategies, by presenting the results of experiments performed on several infinite state systems and temporal properties. Finally, we compare the implementation of our specialization-based verification method with various constraint-based model checking tools. The experimental results show that our method is effective and competitive with respect to the methods used in those other tools.Fabio FioravantiAlberto PettorossiMaurizio ProiettiValerio Sennivalerio.senni@imtlucca.it2012-09-18T13:12:39Z2013-03-07T12:56:25Zhttp://eprints.imtlucca.it/id/eprint/1357This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/13572012-09-18T13:12:39ZProgram transformation for development, verification, and synthesis of programsThis paper briefly describes the use of the program transformation methodology for the development of correct and efficient programs. In particular, we will refer to the case of constraint logic programs and, through some examples, we will show how by program transformation, one can improve, synthesize, and verify programs.Fabio FioravantiAlberto PettorossiMaurizio ProiettiValerio Sennivalerio.senni@imtlucca.it2012-09-18T12:52:48Z2013-03-07T12:56:25Zhttp://eprints.imtlucca.it/id/eprint/1356This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/13562012-09-18T12:52:48ZImproving Reachability Analysis of Infinite State Systems by SpecializationWe consider infinite state reactive systems specified by using linear constraints over the integers, and we address the problem of verifying safety properties of these systems by applying reachability analysis techniques. We propose a method based on program specialization, which improves the effectiveness of the backward and forward reachability analyses. For backward reachability our method consists in: (i) specializing the reactive system with respect to the initial states, and then (ii) applying to the specialized system a reachability analysis that works backwards from the unsafe states. For forward reachability our method works as for backward reachability, except that the role of the initial states and the unsafe states are interchanged. We have implemented our method using the MAP transformation system and the ALV verification system. Through various experiments performed on several infinite state systems, we have shown that our specialization-based verification technique considerably increases the number of successful verifications without significantly degrading the time performance. Fabio FioravantiAlberto PettorossiMaurizio ProiettiValerio Sennivalerio.senni@imtlucca.it2012-09-18T12:09:21Z2013-03-07T12:56:25Zhttp://eprints.imtlucca.it/id/eprint/1354This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/13542012-09-18T12:09:21ZControlling Polyvariance for Specialization-based VerificationWe present some extensions of a method for verifying safety
properties of infinite state reactive systems. Safety properties are specified by constraint logic programs encoding (backward or forward) reachability algorithms. These programs are transformed, before their use for checking safety, by specializing them with respect to the initial states (in the case of backward reachability) or with respect to the unsafe states (in the case of forward reachability). In particular, we present a specialization
strategy which is more general than previous proposals and we show, through some experiments performed on several infinite state reactive systems, that by using the specialized reachability programs obtained by our new strategy, we considerably increase the number of successful
verifications. Then we show that the specialization time, the size of the specialized program, and the number of successful verifications may vary, depending on the polyvariance introduced by the specialization, that is,
the set of specialized predicates which have been introduced. Finally, we propose a general framework for controlling polyvariance and we use our set of examples of infinite state reactive systems to compare in an experimental way various control strategies one may apply in practice.Fabio FioravantiAlberto PettorossiMaurizio ProiettiValerio Sennivalerio.senni@imtlucca.it2012-09-14T14:53:15Z2013-06-20T10:52:52Zhttp://eprints.imtlucca.it/id/eprint/1349This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/13492012-09-14T14:53:15ZGeneralization strategies for the verification of infinite state systemsWe present a method for the automated verification of temporal properties of infinite state systems. Our verification method is based on the specialization of constraint logic programs (CLP) and works in two phases: (1) in the first phase, a CLP specification of an infinite state system is specialized with respect to the initial state of the system and the temporal property to be verified, and (2) in the second phase, the specialized program is evaluated by using a bottom-up strategy. The effectiveness of the method strongly depends on the generalization strategy which is applied during the program specialization phase. We consider several generalization strategies obtained by combining techniques already known in the field of program analysis and program transformation, and we also introduce some new strategies. Then, through many verification experiments, we evaluate the effectiveness of the generalization strategies we have considered. Finally, we compare the implementation of our specialization-based verification method to other constraint-based model checking tools. The experimental results show that our method is competitive with the methods used by those other tools.Fabio FioravantiAlberto PettorossiMaurizio ProiettiValerio Sennivalerio.senni@imtlucca.it2012-09-14T14:18:02Z2013-03-07T12:56:25Zhttp://eprints.imtlucca.it/id/eprint/1348This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/13482012-09-14T14:18:02ZGeneration of Test Data Structures Using Constraint Logic ProgrammingThe goal of Bounded-Exhaustive Testing (BET) is the automatic generation of all the test cases satisfying a given invariant, within a given bound. When the input has a complex structure, the development of correct and efficient generators becomes a very challenging task. In this paper we use Constraint Logic Programming (CLP) to systematically develop generators of structurally complex test data. Similarly to filtering -based test generation, we follow a declarative approach which allows us to separate the issue of (i) defining the test structure and invariant, from that of (ii) generating admissible test input instances. This separation helps improve the correctness of the developed test case generators. However, in contrast with filtering approaches, we rely on a symbolic representation and we take advantage of efficient search strategies provided by CLP systems for generating test instances. Through some experiments on examples taken from the literature on BET, we show that CLP, by combining the use of constraints and recursion, allows one to write intuitive and easily understandable test generators. We also show that these generators can be much more efficient than those built using ad-hoc filtering-based test generation tools like Korat.Valerio Sennivalerio.senni@imtlucca.itFabio Fioravanti2012-09-13T10:58:51Z2013-03-07T12:56:25Zhttp://eprints.imtlucca.it/id/eprint/1345This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/13452012-09-13T10:58:51ZImproving Reachability Analysis of Infinite State Systems by Specialization We consider infinite state reactive systems specified by using linear constraints over the integers, and we address the problem of verifying safety properties of these systems by applying reachability analysis techniques. We propose a method based on program specialization, which improves the effectiveness of the backward and forward reachability analyses. For backward reachability our method consists in: (i) specializing the reactive system with respect to the initial states, and then (ii) applying to the specialized system the reachability analysis that works backwards from the unsafe states. For reasons of efficiency, during specialization we make use of a relaxation from integers to reals. In particular, we test the satisfiability or entailment of constraints over the real numbers, while preserving the reachability properties of the reactive systems when constraints are interpreted over the integers. For forward reachability our method works as for backward reachability, except that the role of the initial states and the unsafe states are interchanged. We have implemented our method using the MAP transformation system and the ALV verification system. Through various experiments performed on several infinite state systems, we have shown that our specialization-based verification technique considerably increases the number of successful verifications without a significant degradation of the time performance.Fabio FioravantiAlberto PettorossiMaurizio ProiettiValerio Sennivalerio.senni@imtlucca.it2012-09-13T10:29:29Z2013-03-07T12:56:25Zhttp://eprints.imtlucca.it/id/eprint/1343This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/13432012-09-13T10:29:29ZUsing Real Relaxations during Program SpecializationWe propose a program specialization technique for locally stratified CLP(ℤ) programs, that is, logic programs with linear constraints over the set ℤ of the integer numbers. For reasons of efficiency our technique makes use of a relaxation from integers to reals. We reformulate the familiar unfold/fold transformation rules for CLP programs so that: (i) the applicability conditions of the rules are based on the satisfiability or entailment of constraints over the set ℝ of the real numbers, and (ii) every application of the rules transforms a given program into a new program with the same perfect model constructed over ℤ. Then, we introduce a strategy which applies the transformation rules for specializing CLP(ℤ) programs with respect to a given query. Finally, we show that our specialization strategy can be applied for verifying properties of infinite state reactive systems specified by constraints over ℤ.Fabio FioravantiAlberto PettorossiMaurizio ProiettiValerio Sennivalerio.senni@imtlucca.it