Verifying Graph Programs with First-Order Logic
Detlef PlumpElectronic Proceedings in Theoretical Computer Science
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
Abstract
We consider Hoare-style verification for the graph programming language GP 2. In previous work, graph properties were specified by so-called E-conditions which extend nested graph conditions. However, this type of assertions is not easy to comprehend by programmers that are used to formal specifications in standard first-order logic. In this paper, we present an approach to verify GP 2 programs with a standard first-order logic. We show how to construct a strongest liberal postcondition with respect to a rule schema and a precondition. We then extend this construction to obtain strongest liberal postconditions for arbitrary loop-free programs. Compared with previous work, this allows to reason about a vastly generalised class of graph programs. In particular, many programs with nested loops can be verified with the new calculus.
Related papers
Hoare-Style Verification of Graph Programs
Fundamenta Informaticae, 2012
GP (for Graph Programs) is an experimental nondeterministic programming language for solving problems on graphs and graph-like structures. The language is based on graph transformation rules, allowing visual programming at a high level of abstraction. In particular, GP frees programmers from dealing with low-level data structures. In this paper, we present a Hoare-style proof system for verifying the partial correctness of (a subset of) graph programs. The pre-and postconditions of the calculus are nested graph conditions with expressions, a formalism for specifying both structural graph properties and properties of labels. We show that our proof system is sound with respect to GP's operational semantics and give examples of its use.
Verifying Graph Programs with Monadic Second-Order Logic
Graph Transformation
To verify graph programs in the language GP 2, we present a monadic second-order logic with counting and a Hoare-style proof calculus. The logic has quantifiers for GP 2's attributes and for sets of nodes or edges. This allows to specify non-local graph properties such as connectedness, k-colourability, etc. We show how to construct a strongest liberal postcondition for a given graph transformation rule and a precondition. The proof rules establish the total correctness of graph programs and are shown to be sound. They allow to verify more programs than is possible with previous approaches. In particular, many programs with nested loops are covered by the calculus.
Hoare logic for graph programs
2010
We present a new approach for verifying programs written in GP (for Graph Programs), an experimental programming language for performing computations on graphs at a high level of abstraction. Taking a labelled graph as input, a graph program nondeterministically applies to it a number of graph transformation rules, directed by simple control constructs such as sequential composition and as-long-as-possible iteration. We adapt classical Hoare logic to the domain of graphs, and describe a system of sound proof rules for showing the partial correctness of graph programs.
Verifying Total Correctness of Graph Programs
2012
GP (for Graph Programs) is an experimental nondeterministic programming language for solving problems on graphs and graph-like structures. The language is based on graph transformation rules, allowing visual programming at a high level of abstraction. Previous work has demonstrated how to verify such programs using a Hoare-style proof system, but only partial correctness was considered. In this paper, we extend our calculus with new rules and termination functions, allowing proofs that program executions always terminate (weak total correctness) and that programs always terminate without failing program runs (total correctness). We show that the new proof system is sound with respect to GP's operational semantics, complete for termination, and demonstrate how it can be used.
A many-sorted logic for graph programs
2012
Abstract. We present a new approach for verifying programs written in GP (for Graph Programs), an experimental programming language for performing computations on graphs at a high level of abstraction. Taking a labelled graph as input, a graph program nondeterministically applies to it a number of graph transformation rules, directed by simple control constructs such as sequential composition and as-long-as-possible iteration. We adapt classical Hoare logic to the domain of graphs, and describe a system of sound proof rules for showing the partial correctness of graph programs. 1
Model checking graph grammars
Proc. Workshop on Automated Verification of Critical …, 2003
We sketch a setup in which transition systems are generated from graph grammars and subsequently checked for properties expressed in a temporal logic on graphs. We envisage this as part of an approach where graph grammars are used to express the behavioural semantics of object-oriented programs, thus enabling automatic verification of those programs.
Explicit state model checking for graph grammars
Concurrency, Graphs and Models, 2008
In this paper we present the philosophy behind the GROOVE project, in which graph transformation is used as a modelling formalism on top of which a model checking approach to software verification is being built. We describe the basic formalism, the current state of the project, and (current and future) challenges.
Two-Level Reasoning About Graph Transformation Programs
Graph Transformation, 2019
This paper presents a method for verifying graph transformation programs written in Small-tALC, an imperative language which allows expressing graph properties and graph transformations in ALCQI description logic. We aim at reasoning not only about the local effect when applying a transformation rule on a matched subgraph but also about the global impact on the whole input graph when applying a set of rules. Using ALCQI assertional and terminological formulae to formalize directed labeled graphs, Small-tALC allows specifying local properties on individual nodes and edges as well as global properties on sets of nodes and edges. Our previous work focuses on verifying local properties of the graph. In this paper, we propose a static analyzer at terminological level that intertwines with a static analyzer at assertional level to infer global properties of the transformed graph.
Graph-transformation verification using monadic second-order logic
Proceedings of the 13th international ACM SIGPLAN symposium on Principles and practices of declarative programming - PPDP '11, 2011
This paper presents a new approach to solving the problem of verification of graph transformation, by proposing a new static verification algorithm for the Core UnCAL, the query algebra for graph-structured databases proposed by Bunemann et al. Given a graph transformation annotated with schema information, our algorithm statically verifies that any graph satisfying the input schema is converted by the transformation to a graph satisfying the output schema. We tackle the problem by first reformulating the semantics of UnCAL into monadic second-order logic (MSO). The logicbased foundation allows to express the schema satisfaction of transformations as the validity of MSO formulas over graph structures. Then by exploiting the two established properties of UnCAL called bisimulation-genericity and compactness, we reduce the problem to the validity of MSO over trees, which has a sound and complete decision procedure. The algorithm has been efficiently implemented; all the graph transformations in this paper and the system web page can be verified within several seconds.
Graph Based Reduction of Program Verification Conditions
Computing Research Repository, 2009
In the verification of C programs by deductive approaches based on automated provers, some heuristics of separation analysis are proposed to handle the most difficult problems. Unfortunately, these heuristics are not sufficient when applied on industrial C programs: some valid verification conditions cannot be automatically discharged by any automated prover mainly due to their size and a high number of irrelevant hypotheses.
Related papers
Using Graph Transformations and Graph Abstractions for Software Verification
Gg, 2010
In this paper we describe our intended approach for the verification of software written in imperative programming languages. We base our approach on model checking of graph transition systems, where each state is a graph and the transitions are specified by graph transformation rules. We believe that graph transformation is a very suitable technique to model the execution semantics of languages with dynamic memory allocation. Furthermore, such representation allows us to investigate the use of graph abstractions, which can mitigate the combinatorial explosion inherent to model checking. In addition to presenting our planned approach, we reason about its feasibility, and, by providing a brief comparison to other existing methods, we highlight the benefits and drawbacks that are expected.
A Method of Verification of Functional Programs Based on Graph Models
2010
In the paper we introduce a concept of a graph model of a functional program. We show how to use this model for verification of functional programs.
The Semantics of Graph Programs
Electronic Proceedings in Theoretical Computer Science, 2010
GP (for Graph Programs) is a rule-based, nondeterministic programming language for solving graph problems at a high level of abstraction, freeing programmers from handling low-level data structures. The core of GP consists of four constructs: single-step application of a set of conditional graphtransformation rules, sequential composition, branching and iteration. We present a formal semantics for GP in the style of structural operational semantics. A special feature of our semantics is the use of finitely failing programs to define GP's powerful branching and iteration commands.
A Layered Approach to Extracting Programs from Proofs with an Application in Graph Theory
Proceedings of the 7th and 8th Asian Logic Conferences, 2003
In this paper we describe our system for automatically extracting \correct" programs from proofs using a development of the Curry-Howard process.
Towards Critical Pair Analysis for the Graph Programming Language GP 2
Lecture Notes in Computer Science, 2017
We present the foundations of critical pair analysis for the graph programming language GP 2. Our goal is to develop a static checker that can prove or refute confluence (functional behaviour) for a large class of graph programs. In this paper, we introduce symbolic critical pairs of GP 2 rule schemata, which are labelled with expressions, and establish the completeness and finiteness of the set of symbolic critical pairs over a finite set of rule schemata. We give a procedure for their construction.
Formal Verification of Object-Oriented Graph Grammars Specifications
Electronic Notes in Theoretical Computer Science, 2007
Concurrent object-oriented systems are ubiquitous due to the importance of networks and the current demands for modular, reusable, and easy to develop software. However, checking the correctness of such systems is a hard task, mainly due to concurrency and inheritance aspects. In this paper we present an approach to the verification of concurrent object-oriented systems. We use graph grammars equipped with object oriented features (including inheritance and polymorphism) as the specification formalism, and define a translation from such specifications to Promela, the input language of the SPIN model checker.
Graph-Query Verification using Monadic Second-Order Logic
This paper presents a static verification algorithm for a core subset of UnCAL, the query algebra for graph-structured databases proposed by Bunemann et al. Given a query and input/output schemas, our algorithm statically verifies that any graph satisfying the input schema is converted by the query to a graph satisfying the output schema. The basic idea is to reformulate the semantics of UnCAL using monadic second-order logic (MSO). The logic-based foundation allows to express the schema satisfaction of transformations as the validity of MSO formulas over graph structures. Furthermore, with several insights on the established properties of UnCAL, the problem turns out to be reducible to the validity of MSO over trees, which has a sound and complete decision procedure.
Towards model checking graph grammars
Workshop on Automated Verification of Critical …
We sketch a setup in which transition systems are generated from graph grammars and subsequently checked for properties expressed in a temporal logic on graphs. We envisage this as part of an approach where graph grammars are used to express the behavioural semantics of object-oriented programs, thus enabling automatic verification of those programs.
Formal Verification of Graph Grammars using Mathematical Induction
Electronic Notes in Theoretical Computer Science, 2009
Graph grammars are a formal description technique suitable for the specification of distributed and reactive systems. Model-checking of graph grammars is currently supported by various approaches. However, in many situations the use of this technique can be very time and space consuming, hindering the verification of properties of many systems. This work proposes a relational and logical approach to graph grammars that allows formal verification of systems using mathematical induction. We use relational structures to define graph grammars and first-order logic to model graph transformations. This approach allows proving properties of systems with infinite state-spaces.
Towards a Rule-Level Verification Framework for Property-Preserving Graph Transformations
We report in this paper a method for proving that a graph transformation is property-preserving. Our approach uses a relational representation for graph grammar and a logical representation for graph properties with first-order logic formulas. The presented work consists in identifying the general conditions for a graph grammar to preserve graph properties, in particular structural properties. We aim to implement all the relevant notions of graph grammar in the Isabelle/HOL proof assistant in order to allow a (semi) automatic verification of graph transformation with a reasonable complexity. Given an input graph and a set of graph transformation rules, we can use mathematical induction strategies to verify statically if the transformation preserves a particular property of the initial graph. The main highlight of our approach is that such a verification is done without calculating the resulting graph and thus without using a transformation engine.
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.