Results 1  10
of
31
Towards graph programs for graph algorithms
 IN ICGT, LNCS 3256
, 2004
"... Graph programs as introduced by Habel and Plump [8] provide a simple yet computationally complete language for computing functions and relations on graphs. We extend this language such that numerical computations on labels can be conveniently expressed. Rather than resorting to some kind of attribu ..."
Abstract

Cited by 19 (4 self)
 Add to MetaCart
(Show Context)
Graph programs as introduced by Habel and Plump [8] provide a simple yet computationally complete language for computing functions and relations on graphs. We extend this language such that numerical computations on labels can be conveniently expressed. Rather than resorting to some kind of attributed graph transformation, we introduce conditional rule schemata which are instantiated to (conditional) doublepushout rules over ordinary graphs. A guiding principle in our language extension is syntactic and semantic simplicity. As a case study for the use of extended graph programs, we present and analyse two versions of Dijkstra’s shortest path algorithm. The first program consists of just three rule schemata and is easily proved to be correct but can be exponential in the number of rule applications. The second program is a refinement of the first which is essentially deterministic and uses at most a quadratic number of rule applications.
Defining and Validating Transformations of UML Models
 IEEE Symposium on Human Centric Computing Languages and Environments (HCC 2003)  Auckland, October 28  October 31 2003, Auckland, New Zealand, Proceedings
, 2003
"... With the success of the UML, the ability of transforming models into programs or formal specifications becomes a key to automated code generation or verification in the software development process. In this paper, we describe a concept for specifying model transformations by means of graph transfor ..."
Abstract

Cited by 18 (5 self)
 Add to MetaCart
(Show Context)
With the success of the UML, the ability of transforming models into programs or formal specifications becomes a key to automated code generation or verification in the software development process. In this paper, we describe a concept for specifying model transformations by means of graph transformation rules on the UML meta model. In order to validate the termination and uniqueness of such transformations we derive a number of sufficient criteria from basic results of the theory of graph transformation. This ensures that the rules can be executed automatically while, at the same time, providing a highlevel visual model of the transformation. 1.
The graph programming language GP
 In Proc. Algebraic Informatics (CAI 2009
, 2009
"... Abstract. GP (for Graph Programs) is a rulebased, nondeterministic programming language for solving graph problems at a high level of abstraction, freeing programmers from handling lowlevel data structures. The core of GP consists of four constructs: singlestep application of a set of conditional ..."
Abstract

Cited by 16 (13 self)
 Add to MetaCart
(Show Context)
Abstract. GP (for Graph Programs) is a rulebased, nondeterministic programming language for solving graph problems at a high level of abstraction, freeing programmers from handling lowlevel data structures. The core of GP consists of four constructs: singlestep application of a set of conditional graphtransformation rules, sequential composition, branching and iteration. This paper gives an overview on the GP project. We introduce the language by discussing a sequence of small programming case studies, formally explain conditional rule schemata which are the building blocks of programs, and present a semantics for GP in the style of structural operational semantics. A special feature of the semantics is how it uses the notion of finitely failing programs to define powerful branching and iteration commands. We also describe GP’s prototype implementation. 1
Datastructure Rewriting
, 2005
"... We tackle the problem of datastructure rewriting including pointer redirections. We propose two basic rewrite steps: (i) Local Redirection and Replacement steps the aim of which is redirecting specific pointers determined by means of a pattern, as well as adding new information to an existing data; ..."
Abstract

Cited by 15 (3 self)
 Add to MetaCart
We tackle the problem of datastructure rewriting including pointer redirections. We propose two basic rewrite steps: (i) Local Redirection and Replacement steps the aim of which is redirecting specific pointers determined by means of a pattern, as well as adding new information to an existing data; and (ii) Global Redirection steps which are aimed to redirect all pointers targeting a node towards another one. We define these two rewriting steps following the double pushout approach. We define first the category of graphs we consider and then define rewrite rules as pairs of graph homomorphisms of the form L ← K → R. Unfortunately, inverse pushouts (complement pushouts) are not unique in our setting and pushouts do not always exist. Therefore, we define rewriting steps so that a rewrite rule can always be performed once a matching is found.
Weakest preconditions for highlevel programs
 In Proc. Graph Transformations (ICGT 2006
, 2006
"... Abstract In proof theory, a standard method for showing the correctness of a program w.r.t. given pre and postconditions is to construct a weakest precondition and to show that the precondition implies the weakest precondition. In this paper, graph programs in the sense of Habel and Plump 2001 ar ..."
Abstract

Cited by 11 (5 self)
 Add to MetaCart
Abstract In proof theory, a standard method for showing the correctness of a program w.r.t. given pre and postconditions is to construct a weakest precondition and to show that the precondition implies the weakest precondition. In this paper, graph programs in the sense of Habel and Plump 2001 are extended to programs over highlevel rules with application conditions, a formal definition of weakest preconditions for highlevel programs in the sense of Dijkstra 1975 is given, and a construction of weakest preconditions is presented. 1
HoareStyle Verification of Graph Programs
, 2012
"... GP (for Graph Programs) is an experimental nondeterministic programming language for solving problems on graphs and graphlike 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 ..."
Abstract

Cited by 8 (5 self)
 Add to MetaCart
GP (for Graph Programs) is an experimental nondeterministic programming language for solving problems on graphs and graphlike 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 lowlevel data structures. In this paper, we present a Hoarestyle 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.
The Semantics of Graph Programs
"... GP (for Graph Programs) is a rulebased, nondeterministic programming language for solving graph problems at a high level of abstraction, freeing programmers from handling lowlevel data structures. The core of GP consists of four constructs: singlestep application of a set of conditional graphtran ..."
Abstract

Cited by 6 (5 self)
 Add to MetaCart
(Show Context)
GP (for Graph Programs) is a rulebased, nondeterministic programming language for solving graph problems at a high level of abstraction, freeing programmers from handling lowlevel data structures. The core of GP consists of four constructs: singlestep 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. 1
A Hoare calculus for graph programs
 In Proc. International Conference on Graph Transformation (ICGT 2010), Lecture
"... Abstract. We present Hoarestyle axiom schemata and inference rules for verifying the partial correctness of programs in the graph programming language GP. The pre and postconditions of this calculus are the nested conditions of Habel, Pennemann and Rensink, extended with expressions for labels in ..."
Abstract

Cited by 5 (3 self)
 Add to MetaCart
(Show Context)
Abstract. We present Hoarestyle axiom schemata and inference rules for verifying the partial correctness of programs in the graph programming language GP. The pre and postconditions of this calculus are the nested conditions of Habel, Pennemann and Rensink, extended with expressions for labels in order to deal with GP’s conditional rule schemata and infinite label alphabet. We show that the proof rules are sound with respect to GP’s operational semantics. 1
Resolutionlike theorem proving for highlevel conditions
 In Proc. Graph Transformations (ICGT 2008
, 2008
"... Abstract. The tautology problem is the problem to prove the validity of statements. In this paper, we present a calculus for this undecidable problem on graphical conditions, prove its soundness, investigate the necessity of each deduction rule, and discuss practical aspects concerning an implementa ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
Abstract. The tautology problem is the problem to prove the validity of statements. In this paper, we present a calculus for this undecidable problem on graphical conditions, prove its soundness, investigate the necessity of each deduction rule, and discuss practical aspects concerning an implementation. As we use the framework of weak adhesive HLR categories, the calculus is applicable to a number of replacement capable structures, such as PetriNets, graphs or hypergraphs. Key words: firstorder tautology problem, highlevel conditions, theorem proving, resolution, weak adhesive HLR categories 1
Modeling Pointer Redirection as Cyclic Termgraph Rewriting
 TERMGRAPH 2006 PRELIMINARY VERSION
, 2006
"... We tackle the problem of datastructure rewriting including global and local pointer redirections. Each basic rewrite step may perform three kinds of actions: (i) Local redirection, the aim of which is to redirect specific pointers determined by means of a pattern; (ii) Replacement, that may add new ..."
Abstract

Cited by 3 (3 self)
 Add to MetaCart
We tackle the problem of datastructure rewriting including global and local pointer redirections. Each basic rewrite step may perform three kinds of actions: (i) Local redirection, the aim of which is to redirect specific pointers determined by means of a pattern; (ii) Replacement, that may add new information to datastructures; (iii) Global redirection, which is aimed at redirecting all pointers targeting a node towards another one. We define a new framework, following the doublepushout approach, where graph rewrite rules may mix these three kinds of actions in a row. We define first the category of graphs we consider and then we define rewrite rules as pairs of graph homomorphisms of the form L ← K → R. In our setting, graph K is not arbitrary, it is used to encode pointer redirection. Furthermore, pushouts do not always exist and complement pushouts, when they exist, are not unique. Despite these concerns, our definition of rewriting steps is such that a rewrite rule can always be fired, once a matching is found.