A needed narrowing strategy

Self Cite

We tackle the problem of data-structure 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 data-structures ; (iii) Global redirection, which is aimed at redirecting all pointers targeting a node towards another one. We define a new framework, following the double-pushout 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.

Section: Resultsmentioning

confidence: 99%

“…4), all pointers targeting cell B, but the one outgoing cell A, in G 1 and redirect them to B[0] in D 1 . The pointer outgoing A, which is locally redirected, points the new variable node A [1] in D 1 . Details of this construction are given in section 4.…”

Section: Introductionmentioning

confidence: 99%

Modeling Pointer Redirection as Cyclic Term-graph Rewriting

Duval¹,

Echahed

Prost

2007

Self Cite

“…These features are presented in the section 4. Our implementation is based on a variation of lazy needed narrowing strategy [4], which is the most common strategy and is the basis of e.g. Curry [9].…”

Section: Basic Approachmentioning

confidence: 99%

Higher-Order Proof Construction Based on First-Order Narrowing

Lindblad

2008

We present the idea of using a proof checking algorithm for the purpose of automated proof construction. This is achieved by applying narrowing search on a proof checker expressed in a functional programming language. We focus on higher-order formalisms, such as logical frameworks, whereas the narrowing techniques we employ are first-order. An obvious advantage of this approach is that a single representation of the semantics can in principle be used for both proof checking and proof construction. The correctness of the search algorithm is consequently more or less trivially provided. The question is whether this representation of the search procedure allows a performance plausible for practical use. In order to achieve this, we add some features to the general narrowing search. We also present some small modifications which can be applied on a proof checker and which further improve the performance. We claim that the resulting proof search procedure is efficient enough for application in an interactive environment, where automation is used mostly on small subproofs.

“…In Section 6.2 we report on two research directions we have been advancing in this area. On the one hand, our goal has been to generalize to arbitrary rewriting systems the extension from lazy rewriting strategies [55,4,5] to lazy narrowing strategies for functional logic programming provided by Antoy, Echahed, and Hanus with their needed narrowing [6,5]. This is an optimal demand-driven strategy that lazily narrows only those outermost positions that are strictly necessary while generating also optimal unifiers.…”

Section: Narrowing As Symbolic Reachability Analysismentioning

confidence: 99%

Narrowing and Rewriting Logic: from Foundations to Applications

Escobar

Meseguer

Thati

2007

Narrowing was originally introduced to solve equational E-unification problems. It has also been recognized as a key mechanism to unify functional and logic programming. In both cases, narrowing supports equational reasoning and assumes confluent equations. The main goal of this work is to show that narrowing can be greatly generalized, so as to support a much wider range of applications, when it is performed with rewrite theories (Σ, E, R), where (Σ, E) is an equational theory, and R is a collection of rewrite rules with no restrictions. Such theories axiomatize concurrent systems, whose states are equivalence classes of terms modulo E, and whose transitions are specified by R. In this context, narrowing is generalized from an equational reasoning technique to a symbolic model checking technique for reachability analysis of a, typically infinite, concurrent system. We survey the foundations of this approach, suitable narrowing strategies, and various applications to security protocol verification, theorem proving, and programming languages.