On the computational complexity of dynamic slicing problems for program schemas

TL;DR

This paper investigates the computational complexity of dynamic slicing problems for program schemas, formalizing definitions, establishing complexity bounds, and proving NP-hardness for certain slicing problems.

Contribution

It formalizes dynamic slicing definitions for linear schemas, analyzes their computational complexity, and proves NP-hardness of finding non-trivial dynamic slices.

Findings

NP-hardness of determining non-trivial dynamic slices

Complexity bounds for slice verification and existence

Minimal dynamic slices may not be unique

Abstract

Given a program, a quotient can be obtained from it by deleting zero or more statements. The field of program slicing is concerned with computing a quotient of a program which preserves part of the behaviour of the original program. All program slicing algorithms take account of the structural properties of a program such as control dependence and data dependence rather than the semantics of its functions and predicates, and thus work, in effect, with program schemas. The dynamic slicing criterion of Korel and Laski requires only that program behaviour is preserved in cases where the original program follows a particular path, and that the slice/quotient follows this path. In this paper we formalise Korel and Laski's definition of a dynamic slice as applied to linear schemas, and also formulate a less restrictive definition in which the path through the original program need not be preserved by the slice. The less restrictive definition has the benefit of leading to smaller slices. For both definitions, we compute complexity bounds for the problems of establishing whether a given slice of a linear schema is a dynamic slice and whether a linear schema has a non-trivial dynamic slice and prove that the latter problem is NP-hard in both cases. We also give an example to prove that minimal dynamic slices (whether or not they preserve the original path) need not be unique.

Equations

$$arity:\mathcal{F}\cup \mathcal{P}\to \mathbb{N}.$$

$$\mathcal{M}[[S]{]}_d^i=\mathcal{M}[[schema({\pi }_S(i,d))]{]}_d^i$$

$${\pi }_{S_1{S}_2}(i,d)={\pi }_{S_1}(i,d){\pi }_{S_2}(i,\mathcal{M}[[S_1]{]}_d^i)$$

$$\rho =(\underline{p,\mathsf{T}}\underline{g}\underline{f}\underline{q,\mathsf{T}}\underline{h}\underline{H}{)}^2\underline{p,\mathsf{F}}$$

$${\rho }^{\prime }=\underline{p,\mathsf{T}}\underline{g}\underline{f}\underline{q,\mathsf{T}}\underline{h}\underline{H}\underline{p,\mathsf{T}}\underline{g}\underline{f}\underline{q,\mathsf{F}}\underline{p,\mathsf{F}}$$

$${\rho }_{i+1}={\alpha }_i\underline{p_i,\neg Z_i}{\gamma }_i={\alpha }_{i+1}\underline{p_{i+1},Z_{i+1}}{\beta }_{i+1}{\gamma }_{i+1}.$$

$${\rho }_i={\alpha }_{i+1}\underline{p_{i+1},Z_{i+1}}{\delta }_1\underline{p_i,Z_i}{\beta }_i{\delta }_2{\gamma }_{i+1}$$

Full text

1 Introduction

A schema represents the statement structure of a program by replacing real functions and predicates by symbols representing them. A schema, ${S}$, thus defines a whole class of programs which all have the same structure. A schema is linear if it does not contain more than one occurrence of the same function or predicate symbol. As an example, Figure 1 gives a schema $S$; and Figure 2 shows one of the programs obtainable from the schema of Figure 1 by interpreting its function and predicate symbols.

The subject of schema theory is connected with that of program transformation and was originally motivated by the wish to compile programs effectively[1]. Thus an important problem in schema theory is that of establishing whether two schemas are equivalent; that is, whether they always have the same termination behaviour, and give the same final value for every variable, given any initial state and any interpretation of function and predicate symbols. In Section 1.2, the history of this problem is discussed.

Schema theory is also relevant to program slicing, and this is the motivation for the main results of this paper. We define a quotient of a schema $S$ to be any schema obtained by deleting zero or more statements from $S$. A quotient of $S$ is non-trivial if it is distinct from $S$. Thus a quotient of a schema is not required to satisfy any semantic condition; it is defined purely syntactically. The field of program slicing is concerned with computing a quotient of a program which preserves part of the behaviour of the original program. Program slicing is used in program comprehension [2, 3], software maintenance [4, 5, 6, 7], and debugging [8, 9, 10, 11].

All program slicing algorithms take account of the structural properties of a program such as control dependence and data dependence rather than the semantics of its functions and predicates, and thus work, in effect, with linear program schemas. There are two main forms of program slicing; static and dynamic.

• •

In static program slicing, only the program itself is used to construct a slice. Most static slicing algorithms are based on Weiser’s algorithm[12], which uses the data and control dependence relations of the program in order to compute the set of statements which the slice retains. An end-slice of a program with respect to a variable $v$ is a slice that always returns the same final value for $v$ as the original program, when executed from the same input. It has been proved that Weiser’s algorithm gives minimal static end-slices[13] for linear, free, liberal program schemas. This result has recently been strengthened by allowing function-linear schemas, in which only predicate symbols are required to be non-repeating[14].

• •

In dynamic program slicing, a path through the program is also used as input. Dynamic slices of programs may be smaller than static slices, since they are only required to preserve behaviour in cases where the original program follows a particular path. As originally formulated by Korel and Laski [15], a dynamic slice of a program $P$ is defined by three parameters besides $P$, namely a variable set $V$, an initial input state $d$ and an integer $n$. The slice with respect to these parameters is required to follow the same path as $P$ up to the $n$th statement (with statements not lying in the slice deleted from the path through the slice) and give the same value for each element of $V$ as $P$ after the $n$th statement after execution from the initial state $d$. Many dynamic slicing algorithms have been written [16, 17, 18, 19, 20, 15, 21, 22]. Most of these compute a slice using the data and control dependence relations along the given path through the original program. This produces a correct slice, and uses polynomial time, but need not give a minimal or even non-trivial slice even where one exists.

Our definition of a path-faithful dynamic slice (PFDS) for a linear schema $S$ comprises two parameters besides $S$, namely a path through $S$ and a variable set, but not an initial state. This definition is analogous to that of Korel and Laski, since the initial state included in their parameter set is used solely in order to compute a path through the program in linear schema-based slicing algorithms. We prove, in effect, that it is decidable in polynomial time whether a particular quotient of a program is a dynamic slice in the sense of Korel and Laski, and that the problem of establishing whether a program has a non-trivial path-faithful dynamic slice is intractable, unless P$=$NP. This shows that there does not exist a tractable dynamic slicing algorithm that produces correct slices and always gives a non-trivial slice of a program where one exists.

The requirement of Korel and Laski that the path through the slice be path-faithful may seem unnecessarily strong. Therefore we define a more general dynamic slice (DS), in which the sequence of functions and predicates through which the path through the slice passes is a subsequence of that for the path through the original schema, but the path through the slice must still pass the same number of times through the program point at the end of the original path. For this less restrictive definition, we prove that it is decidable in Co-NP time whether a particular slice of a program is a dynamic slice, and the problem of establishing whether a program has a non-trivial dynamic slice is NP-hard.

We also give an example to prove that unique minimal dynamic slices (whether or not path-faithful) of a linear schema $S$ do not always exist.

The results of this paper have several practical ramifications. First, we prove that the problem of deciding whether a linear schema has a non-trivial dynamic slice is computationally hard and clearly this result must also hold for programs. In addition, since this decision problem is computationally hard, the problem of producing minimal dynamic slices must also be computationally hard. Second, we define a new notion of a dynamic slice that places strictly weaker constraints on the slice than those traditionally used and thus can lead to smaller dynamic slices. In Section 4 we explain why these (smaller) dynamic slices can be appropriate, motivating this through a problem in program testing. Naturally, this weaker notion of a dynamic slice is also directly applicable to programs. Finally, we prove that minimal dynamic slices need not be unique and this has consequences when designing dynamic slicing algorithms since it tells us that algorithms that identify and then delete one statement at a time can lead to suboptimal dynamic slices.

It should be noted that much theoretical work on program slicing and program analysis, including that of Müller-Olm’s study of dependence analysis of parallel programs [23], and on deciding validity of relations between variables at given program points [24, 25] only considers programs in which branching is treated as non-deterministic, and is thus more ‘approximate’ than our own in this respect, in that we take into account control dependence as part of the program structure.

1.1 Different classes of schemas

Many subclasses of schemas have been defined:

Structured schemas,

in which goto commands are forbidden, and thus loops must be constructed using while statements. All schemas considered in this paper are structured.

Linear schemas,

in which each function and predicate symbol occurs at most once.

Free schemas,

where all paths are executable under some interpretation.

Conservative schemas,

in which every assignment is of the form

$v\,{\tt{:=}}\,f(v_{1},\ldots,v_{r});$ where $v\in\{v_{1},\ldots,v_{r}\}$.

Liberal schemas,

in which two assignments along any executable path can always be made to assign distinct values to their respective variables by a suitable choice of domain.

It can be easily shown that all conservative schemas are liberal.

Paterson [26] gave a proof that it is decidable whether a schema is both liberal and free; and since he also gave an algorithm transforming a schema $S$ into a schema $T$ such that $T$ is both liberal and free if and only if $S$ is liberal, it is clearly decidable whether a schema is liberal. It is an open problem whether freeness is decidable for the class of linear schemas. However he also proved, using a reduction from the Post Correspondence Problem, that it is not decidable whether a schema is free.

1.2 Previous results on the decidability of schema equivalence

Most previous research on schemas has focused on schema equivalence. All results on the decidability of equivalence of schemas are either negative or confined to very restrictive classes of schemas. In particular Paterson [27] proved that equivalence is undecidable for the class of all schemas containing at least two variables, using a reduction from the halting problem for Turing machines. Ashcroft and Manna showed [28] that an arbitrary schema, which may include goto commands, can be effectively transformed into an equivalent structured schema, provided that statements such as $\,\mathit{while}\,\neg p(\mathbf{u})\,\mathit{do}\,T$ are permitted; hence Paterson’s result shows that any class of schemas for which equivalence can be decided must not contain this class of schemas. Thus in order to get positive results on this problem, it is clearly necessary to define the relevant classes of schema with great care.

Positive results on the decidability of equivalence of schemas include the following; in an early result in schema theory, Ianov [29] introduced a restrictive class of schemas, the Ianov schemas, for which equivalence is decidable. This problem was later shown to be NP-complete [30, 31]. Ianov schemas are characterised by being monadic (that is, they contain only a single variable) and having only unary function symbols; hence Ianov schemas are conservative.

Paterson [26] proved that equivalence is decidable for a class of schemas called progressive schemas, in which every assignment references the variable assigned by the previous assignment along every legal path.

Sabelfeld [32] proved that equivalence is decidable for another class of schemas called through schemas. A through schema satisfies two conditions: firstly, that on every path from an accessible predicate $p$ to a predicate $q$ which does not pass through another predicate, and every variable $x$ referenced by $p$, there is a variable referenced by $q$ which defines a term containing the term defined by $x,$ and secondly, distinct variables referenced by a predicate can be made to define distinct terms under some interpretation.

It has been proved that for the class of schemas which are linear, free and conservative, equivalence is decidable [33]. More recently, the same conclusion was proved to hold under the weaker hypothesis of liberality in place of conservatism [34, 35].

1.3 Organisation of the paper

In Section 2 we give basic definitions of schemas. In Section 3 we define path-faithful dynamic slices and in Section 4 we define general dynamic slices. In Section 5 we give an example to prove that unique minimal dynamic slices need not exist. In Section 6 we prove complexity bounds for problems concerning the existence of dynamic slices. Lastly, in Section 7, we discuss further directions for research in this area.

2 Basic Definitions of Schemas

Throughout this paper, $\mathcal{F}$, $\mathcal{P}$, $\mathcal{V}$ and $\mathcal{L}$ denote fixed infinite sets of function symbols, predicate symbols, variables and labels respectively. A symbol means an element of ${\mathcal{F}}\cup{\mathcal{P}}$ in this paper. For example, the schema in Figure 1 has function set $\mathcal{F}=\{f,g,h\}$, predicate set $\mathcal{P}=\{p\}$ and variable set $\mathcal{V}=\{u,v\}$. We assume a function

[TABLE]

The arity of a symbol $x$ is the number of arguments referenced by $x$, for example in the schema in Figure 1 the function $f$ has arity one, the function $g$ has arity zero, and $p$ has arity one.

Note that in the case when the arity of a function symbol $g$ is zero, $g$ may be thought of as a constant.

The set $\mathit{Term}({\mathcal{F}},{\mathcal{V}})$ of terms is defined as follows:

• •

each variable is a term,

• •

if $f\in{\mathcal{F}}$ is of arity $n$ and $t_{1},\ldots,t_{n}$ are terms then $f(t_{1},\ldots,t_{n})$ is a term.

For example, in the schema in Figure 1, the variable $u$ takes the value (term) $h();$ after the first assignment is executed and if we take the true branch then the variable $v$ ends with the value (term) $f(h())$.

We refer to a tuple ${\mathbf{t}}=(t_{1},\ldots,t_{n})$, where each $t_{i}$ is a term, as a vector term. We call $p({\mathbf{t}})$ a predicate term if $p\in\mathcal{P}$ and the number of components of the vector term ${\mathbf{t}}$ is $\mathit{arity}(p)$.

Schemas are defined recursively as follows.

• •

$\mathit{skip}$ is a schema.

• •

Any label is a schema.

• •

An assignment $y\,{\tt{:=}}\,f({\mathbf{x}});$ for a variable $y$, a function symbol $f$ and an $n$-tuple ${\mathbf{x}}$ of variables, where $n$ is the arity of $f$, is a schema.

• •

If $S_{1}$ and $S_{2}$ are schemas then $S_{1}S_{2}$ is a schema.

• •

If $S_{1}$ and $S_{2}$ are schemas, $p$ is a predicate symbol and ${\mathbf{y}}$ is an $m$-tuple of variables, where $m$ is the arity of $p$, then $\,\mathit{if}\,p({\mathbf{y}})\,\mathit{then}\,S_{1}\,\mathit{else}\,S_{2}$ is a schema.

• •

If $T$ is a schema, $q$ is a predicate symbol and ${\mathbf{z}}$ is an $m$-tuple of variables, where $m$ is the arity of $q$, then the schema $\,\mathit{while}\,q({\mathbf{z}})\;T$ is a schema.

If no function or predicate symbol, or label, occurs more than once in a schema $S$, we say that $S$ is linear. If a schema does not contain any predicate symbols, then we say it is predicate-free. If a linear schema $S$ contains a subschema $\,\mathit{if}\,p({\mathbf{y}})\,\mathit{then}\,S_{1}\,\mathit{else}\,S_{2}$, then we refer to $S_{1}$ and $S_{2}$ as the ${\mathsf{T}}$-part and ${\mathsf{F}}$-part respectively of $p$ in $S$. For example in the schema in Figure 1 the predicate $p$ has ${\mathsf{T}}$-part $v\,{\tt{:=}}\,f(u);$ and ${\mathsf{F}}$-part $v\,{\tt{:=}}\,g();$. If a linear schema $S$ contains a subschema $\,\mathit{while}\,q({\mathbf{z}})\;T$, then we refer to $T$ as the body of $q$ in $S$.

Quotients of schemas are defined recursively as follows; $\mathit{skip}$ is a quotient of every schema; if $S^{\prime}$ is a quotient of $S$ then $S^{\prime}T$ is a quotient of $ST$ and $TS^{\prime}$ is a quotient of $TS$; if $T^{\prime}$ is a quotient of $T$, then $\,\mathit{while}\,q({\mathbf{y}})\;T^{\prime}$ is a quotient of $\,\mathit{while}\,q({\mathbf{y}})\;T$; and if $T_{1}$ and $T_{2}$ are quotients of schemas $S_{1}$ and $S_{2}$ respectively, then $\,\mathit{if}\,p({\mathbf{x}})\,\mathit{then}\,T_{1}\,\mathit{else}\,T_{2}$ is a quotient of $\,\mathit{if}\,p({\mathbf{x}})\,\mathit{then}\,S_{1}\,\mathit{else}\,S_{2}$. A quotient $T$ of a schema $S$ is said to be non-trivial if $T\not=S$.

Consider the schema in Figure 1. Here we can obtain a quotient by replacing the first statement by $\mathit{skip}$ or by replacing the if statement by $\mathit{skip}$. It is also possible to replace either or both parts of the if statement by $\mathit{skip}$ or any combination of these steps.

2.1 Paths through a schema

We will express the semantics of schemas using paths through them; therefore the definition of a path through a schema has to include the variables assigned or referenced by successive function or predicate symbols.

The set of prefixes of a word (that is, a sequence) $\sigma$ over an alphabet is denoted by $\mathit{pre}(\sigma)$. For example, if $\sigma=x_{1}x_{3}x_{2}$ over the alphabet $\{x_{1},x_{2},x_{3}\}$, then the set $\mathit{pre}(\sigma)$ consists of the words $x_{1}x_{2}x_{3},x_{1}x_{2},x_{1}$ and the empty word. More generally, if $\Omega$ is a set of words, then we define $\mathit{pre}(\Omega)=\{\mathit{pre}(\sigma)|\;\sigma\in\Omega\}$.

For each schema $S$ there is an associated alphabet ${\mathit{a}lphabet}(S)$ consisting of all elements of $\mathcal{L}$ and the set of letters of the form $\underline{y\,{\tt{:=}}\,f({\mathbf{x}})}$ for assignments $y\,{\tt{:=}}\,f({\mathbf{x}});$ in $S$ and $\underline{p({\mathbf{y}}),Z}$ for $Z\in\{{\mathsf{T}},{\mathsf{F}}\}$, where $\,\mathit{if}\,p({\mathbf{y}})$ or $\,\mathit{while}\,p({\mathbf{y}})$ occurs in $S$. For example, the schema in Figure 1 has no labels and has alphabet

$\{\underline{y\,{\tt{:=}}\,h()},\underline{v\,{\tt{:=}}\,f(\mathbf{u})},\underline{v\,{\tt{:=}}\,g()},\underline{p(\mathbf{w}),{\mathsf{T}}},\underline{p(\mathbf{w}),{\mathsf{F}}}\}$. The set $\Pi(S)$ of terminating paths through $S$, is defined recursively as follows.

• •

$\Pi(l)=l$, for any $l\in\mathcal{L}$.

• •

$\Pi(\mathit{skip})$ is the empty word.

• •

$\Pi(y\,{\tt{:=}}\,f({\mathbf{x}});)=\underline{y\,{\tt{:=}}\,f({\mathbf{x}})}$.

• •

$\Pi(S_{1}S_{2})=\Pi(S_{1})\,\Pi(S_{2})$.

• •

$\Pi(\,\mathit{if}\,p({\mathbf{x}})\,\mathit{then}\,S_{1}\,\mathit{else}\,S_{2})=\,\underline{p({\mathbf{x}}),{\mathsf{T}}}\,\Pi(S_{1})\cup\,\underline{p({\mathbf{x}}),{\mathsf{F}}}\,\Pi(S_{2})$.

• •

$\Pi(\,\mathit{while}\,(q({\mathbf{y}})\,T))=\,(\underline{q({\mathbf{y}}),{\mathsf{T}}}\,\Pi(T))^{*}\,\underline{q({\mathbf{y}}),{\mathsf{F}}}$.

We sometimes abbreviate $\underline{q({\mathbf{y}}),Z}$ to $\underline{q,Z}$ and $\underline{y\,{\tt{:=}}\,f({\mathbf{x}})}$ to $\underline{f}$.

We define $\Pi^{\omega}(S)$ to be the set containing $\Pi(S)$, plus all infinite words whose finite prefixes are prefixes of terminating paths. A path through $S$ is any (not necessarily strict) prefix of an element of $\Pi^{\omega}(S)$. As an example, if $S$ is the schema in Figure 1, which has no loops, then $\Pi(S)=\Pi^{\omega}(S)$. In fact, $\Pi(S)$ in this case contains exactly two paths, defined by $p(\mathbf{w})$ taking the true or false branches, and every path through $S$ is a prefix of one of these paths.

If $S^{\prime}$ is a quotient of a schema $S$, and $\rho\in\mathit{pre}(\Pi(S))$ (that is, $\rho$ is a path through $S$), then ${\mathit{proj}}_{S^{\prime}}(\rho)$ is the path obtained from $\rho$ by deleting all letters having function or predicate symbols not lying in $S^{\prime}$ and all labels not occurring in $S^{\prime}$. It is easily proved that ${\mathit{proj}}_{S^{\prime}}(\Pi(S))=\Pi(S^{\prime})$ in this case.

2.2 Semantics of schemas

The symbols upon which schemas are built are given meaning by defining the notions of a state and of an interpretation. It will be assumed that ‘values’ are given in a single set $D$, which will be called the domain. We are mainly interested in the case in which $D=\mathit{Term}(\mathcal{F},\mathcal{V})$ (the Herbrand domain) and the function symbols represent the ‘natural’ functions with respect to $\mathit{Term}(\mathcal{F},\mathcal{V})$.

Definition 1** (states, (Herbrand) interpretations and the natural state $e$)**

Given a domain $D$, a state is either $\bot$ (denoting non-termination) or a function $\mathcal{V}\rightarrow D$. The set of all such states will be denoted by ${\rm State}(\mathcal{V},D)$. An interpretation $i$ defines, for each function symbol $f\in\mathcal{F}$ of arity $n$, a function $f^{i}:D^{n}\rightarrow D$, and for each predicate symbol $p\in\mathcal{P}$ of arity $m$, a function $p^{i}:D^{m}\rightarrow\{{\mathsf{T}},\,{\mathsf{F}}\}$. The set of all interpretations with domain $D$ will be denoted $\mathit{Int}({\mathcal{F}},{\mathcal{P}},D)$.

We call the set $\mathit{Term}(\mathcal{F},\mathcal{V})$ of terms the Herbrand domain, and we say that a function from $\mathcal{V}$ to $\mathit{Term}(\mathcal{F},\mathcal{V})$ is a Herbrand state. An interpretation $i$ for the Herbrand domain is said to be Herbrand if the functions $f^{i}:\,\mathit{Term}(\mathcal{F},\mathcal{V})^{n}\to\mathit{Term}(\mathcal{F},\mathcal{V})$ for each $f\in\mathcal{F}$ are defined as

$f^{i}(t_{1},\ldots,t_{n})=f(t_{1},\ldots,t_{n})$

for all $n$-tuples of terms $(t_{1},\ldots,t_{n})$.

We define the natural state $e:\mathcal{V}\rightarrow\mathit{Term}(\mathcal{F},\mathcal{V})$ by $e(v)=v$ for all $v\in\mathcal{V}.$

In the schema in Figure 1 the natural state simply maps variable $\mathbf{u}$ to the name $u$, variable $\mathbf{v}$ to the name $v$, and variable $\mathbf{w}$ to the name $w$. The program in Figure 2 can be produced from this schema through the interpretation that maps $h();$ to $1$, $p(\mathbf{w})$ to $\mathbf{w}>1$, $f(\mathbf{u})$ to $\mathbf{u}+1$, and $g()$ to $2$; clearly this is not a Herbrand interpretation.

Observe that if an interpretation $i$ is Herbrand, this does not restrict the mappings

$p^{i}:(\mathit{Term}({\mathcal{F}},\mathcal{V}))^{m}\rightarrow\{{\mathsf{T}},\,{\mathsf{F}}\}$ defined by $i$ for each $p\in\mathcal{P}$.

It is well known  [36, Section 4-14] that Herbrand interpretations are the only ones that need to be considered when considering many schema properties. This fact is stated more precisely in Theorem 8. In particular, our semantic slicing definitions may be defined in terms of Herbrand domains.

Given a schema $S$ and a domain $D$, an initial state $d\in{\rm State}(\mathcal{V},D)$ with $d\not=\bot$ and an interpretation $i\in\mathit{Int}({\mathcal{F}},{\mathcal{P}},D)$ we now define the final state ${\mathcal{M}}[\![{S}]\!]^{i}_{d}\in{\rm State}(\mathcal{V},D)$ and the associated path ${\pi}_{S}(i,d)\in\Pi^{\omega}(S)$. In order to do this, we need to define the predicate-free schema associated with the prefix of a path by considering the sequence of assignments through which it passes.

Definition 2** (the schema $\mathit{schema}(\sigma)$)**

Given a word $\sigma\in({\mathit{a}lphabet}(S))^{*}$ for a schema $S$, we recursively define the predicate-free schema $\mathit{schema}(\sigma)$ by the following rules; $\,\mathit{schema}(\mathit{skip})=\mathit{skip}$, $\,\mathit{schema}(l)=l$ for $l\in\mathcal{L}$, $\mathit{schema}(\sigma\underline{v\,{\tt{:=}}\,{f}({\mathbf{x}})})\;=\;\mathit{schema}(\sigma)\,v\,{\tt{:=}}\,{f}({\mathbf{x}});$ and $\mathit{schema}(\sigma\underline{p({\mathbf{x}}),X})\;=\;\mathit{schema}(\sigma)$.

Consider, for example, the path of the schema in Figure 1 that passes through the true branch of $p$. Then this defines a word $\sigma=\underline{u\,{\tt{:=}}\,{h}()}\underline{p(\mathbf{w}),{\mathsf{T}}}\underline{v\,{\tt{:=}}\,{f}(\mathbf{u})}$ and $\mathit{schema}(\sigma)=\underline{u\,{\tt{:=}}\,{h}()}\underline{v\,{\tt{:=}}\,{f}(\mathbf{u})}$.

Lemma 3

Let $S$ be a schema. If $\sigma\in\mathit{pre}(\Pi(S))$, the set $\{m\in{\mathit{a}lphabet}(S)|\,\sigma m\in\mathit{pre}(\Pi(S))\}$ is one of the following; a label, a singleton containing an assignment letter $\underline{y\,{\tt{:=}}\,f({\mathbf{x}})}$, a pair $\{\underline{{p}({\mathbf{x}}),{\mathsf{T}}},\;\underline{{p}({\mathbf{x}}),{\mathsf{F}}}\}$ for a predicate $p$ of $S$, or the empty set, and if $\sigma\in\Pi(S)$ then the last case holds.

Proof. [14, Lemma 6]. $\;\square$

Lemma 3 reflects the fact that at any point in the execution of a program, there is never more than one ‘next step’ which may be taken, and an element of $\Pi(S)$ cannot be a strict prefix of another.

Definition 4** (semantics of predicate-free schemas)**

Given a state $d\not=\bot$, the final state ${\mathcal{M}}[\![{S}]\!]^{i}_{d}$ and associated path ${\pi}_{S}(i,d)\in\Pi^{\omega}(S)$ of a schema $S$ are defined as follows:

• •

${\mathcal{M}}[\![{\mathit{skip}}]\!]^{i}_{d}=d$ and ${\pi}_{\mathit{skip}}(i,d)$ is the empty word.

• •

${\mathcal{M}}[\![{l}]\!]^{i}_{d}=d$ and ${\pi}_{l}(i,d)=l$ for $l\in\mathcal{L}$.

• •

{\mathcal{M}}[\![{y\,{\tt{:=}}\,f({\mathbf{x}});}]\!]^{i}_{d}(v)~{}~{}~{}=~{}~{}~{}\begin{cases}d(v)&\text{if v\not=y},\\ f^{i}(d({\mathbf{x}}))&\text{if v=y }\end{cases} (where the vector term $d({\mathbf{x}})=(d(x_{1}),\ldots,d(x_{n}))$ for ${\mathbf{x}}=(x_{1},\ldots,x_{n})$), and

${\pi}_{y\,{\tt{:=}}\,f({\mathbf{x}});}(i,d)~{}~{}~{}=~{}~{}~{}\underline{y\,{\tt{:=}}\,f({\mathbf{x}})}$.

• •

For sequences $S_{1}S_{2}$ of predicate-free schemas, ${\mathcal{M}}[\![{S_{1}S_{2}}]\!]^{i}_{d}~{}~{}~{}=~{}~{}~{}{\mathcal{M}}[\![{S_{2}}]\!]^{i}_{{\mathcal{M}}[\![{S_{1}}]\!]^{i}_{d}}$ and

${\pi}_{S_{1}S_{2}}(i,d)~{}~{}~{}=~{}~{}~{}{\pi}_{S_{1}}(i,d){\pi}_{S_{2}}(i,{\mathcal{M}}[\![{S_{1}}]\!]^{i}_{d})$.

This uniquely defines ${\mathcal{M}}[\![{S}]\!]^{i}_{d}$ and ${\pi}_{S}(i,d)$ if $S$ is predicate-free. In order to give the semantics of a general schema $S$, first the path, ${\pi}_{S}(i,d)$, of $S$ with respect to interpretation, $i$, and initial state $d$ is defined.

Definition 5** (the path ${\pi}_{S}(i,d)$)**

Given a schema $S$, an interpretation $i$, and a state, $d\not=\bot$, the path ${\pi}_{S}(i,d)\in\Pi^{\omega}(S)$ is defined by the following condition; for all

$\sigma\,\underline{p({\mathbf{x}}),Z}\;\in\mathit{pre}({\pi}_{S}(i,d))$, the equality $p^{i}({\mathcal{M}}[\![{\mathit{schema}(\sigma)}]\!]^{i}_{d}({\mathbf{x}}))=Z$ holds.

In other words, the path ${\pi}_{S}(i,d)$ has the following property; if a predicate expression $p({\mathbf{x}})$ along ${\pi}_{S}(i,d)$ is evaluated with respect to the predicate-free schema consisting of the sequence of assignments preceding that predicate in ${\pi}_{S}(i,d)$, then the value of the resulting predicate term given by $i$ ‘agrees’ with the value given in ${\pi}_{S}(i,d)$. Consider, for example, the schema given in Figure 1 and the interpretation that gives the program in Figure 2. Given a state $d$ in which $w$ has a value greater than one, we obtain the path $\underline{u\,{\tt{:=}}\,{h}()}\;\underline{p(\mathbf{w}),{\mathsf{T}}}\;\underline{v\,{\tt{:=}}\,{f}(\mathbf{u})}$.

By Lemma 3, this defines the path ${\pi}_{S}(i,d)\in\Pi^{\omega}(S)$ uniquely.

Definition 6** (the semantics of arbitrary schemas)**

If ${\pi}_{S}(i,d)$ is finite, we define

[TABLE]

(which is already defined, since $\mathit{schema}({\pi}_{S}(i,d))$ is predicate-free) otherwise ${\pi}_{S}(i,d)$ is infinite and we define ${\mathcal{M}}[\![{S}]\!]^{i}_{d}=\bot$. In this last case we may say that ${\mathcal{M}}[\![{S}]\!]^{i}_{d}$ is not terminating.

For convenience, if $S$ is predicate-free and $d:\mathcal{V}\rightarrow\mathit{Term}(\mathcal{F},\mathcal{V})$ is a state then we define unambiguously ${\mathcal{M}}[\![{S}]\!]_{d}={\mathcal{M}}[\![{S}]\!]^{i}_{d}$; that is, we assume that the interpretation $i$ is Herbrand if $d$ is a Herbrand state. Also, if $\rho$ is a path through a schema, we may write ${\mathcal{M}}[\![{\rho}]\!]_{e}$ to mean ${\mathcal{M}}[\![{\mathit{schema}(\rho)}]\!]_{e}$.

Observe that ${\mathcal{M}}[\![{S_{1}S_{2}}]\!]^{i}_{d}={\mathcal{M}}[\![{S_{2}}]\!]^{i}_{{\mathcal{M}}[\![{S_{1}}]\!]^{i}_{d}}$ and

[TABLE]

hold for all schemas (not just predicate-free ones).

Given a schema $S$ and $\mu\in\mathit{pre}(\Pi(S))$, we say that $\mu$ passes through a predicate term $p({\mathbf{t}})$ if $\mu$ has a prefix $\mu^{\prime}$ ending in $\underline{{p}({\mathbf{x}}),Y}$ for $y\in\{{\mathsf{T}},{\mathsf{F}}\}$ such that ${\mathcal{M}}{[\![{\mathit{schema}(\mu^{\prime})}]\!]_{{e}}}({\mathbf{x}})={\mathbf{t}}$ holds. In this case we say that $p({\mathbf{t}})=Y$ is a consequence of $\mu$. For example, the path $\underline{u\,{\tt{:=}}\,{h}()}\;\underline{p(\mathbf{w}),{\mathsf{T}}}\;\underline{v\,{\tt{:=}}\,{f}(\mathbf{u})}$ of the schema in Figure 1 passes through the predicate term $p(\mathbf{w})$ since this path has no assignments to $w$ before $p$.

Definition 7** (path compatibility and executability)**

Let $\rho$ be a path through a schema $S$. Then $\rho$ is executable if $\rho$ is a prefix of ${\pi}_{S}(j,d)$ for some interpretation $j$ and state $d$. Two paths $\rho,\rho^{\prime}$ through schemas $S,S^{\prime}$ are compatible if for some interpretation $j$ and state $d$, they are prefixes of ${\pi}_{S}(j,d)$ and ${\pi}_{S^{\prime}}(j,d)$ respectively.

The justification for restricting ourselves to consideration of Herbrand interpretations and the state $e$ as the initial state lies in the fact that Herbrand interpretations are the ‘most general’ of interpretations. Theorem 8, which is virtually a restatement of [36, Theorem 4-1], expresses this formally.

Theorem 8

Let $\chi$ be a set of schemas, let $D$ be a domain, let $d$ be a function from the set of variables into $D$ and let $i$ be an interpretation using this domain. Then there is a Herbrand interpretation $j$ such that the following hold.

1. (1)

For all $S\in\chi$, the path ${\pi}_{S}(j,e)={\pi}_{S}(i,d)$. 2. (2)

If $S_{1},S_{2}\in\chi$ and $v_{1},v_{2}$ are variables and $\rho_{k}\in\mathit{pre}({\pi}_{S_{k}}(j,e))$ for $k=1,2$ and ${\mathcal{M}}[\![{\rho_{1}}]\!]_{e}(v_{1})={\mathcal{M}}[\![{\rho_{2}}]\!]_{e}(v_{2})$, then also ${\mathcal{M}}[\![{\rho_{1}}]\!]^{i}_{d}(v_{1})={\mathcal{M}}[\![{\rho_{2}}]\!]^{i}_{d}(v_{2})$ holds.

As a consequence of Part (1) of Theorem 8, it may be assumed in Definition 7 that $d=e$ and the interpretation  $j$ is Herbrand without strengthening the Definition. In the remainder of the paper we will assume that all interpretations are Herbrand.

3 The path-faithful dynamic slicing criterion

In this section we adapt the notion of a dynamic program slice to program schemas. Dynamic program slicing is formalised in the original paper by Korel and Laski [15]. Their definition uses two functions, $Front$ and $DEL$, in which $Front(T,i)$ denotes the first $i$ elements of a trajectory111A trajectory is a path in which we do not distinguish between true and false values for a predicate. There is a one-to-one correspondence between paths and trajectories unless there is an if statement that contains only $\mathit{skip}$. $T$ and $DEL(T,\pi)$ denotes the trajectory $T$ with all elements that satisfy predicate $\pi$ removed. A trajectory is a path through a program, where each node is represented by a line number and so for path $\rho$ we have that $\hat{\rho}$ is the corresponding trajectory.

Korel and Laski use a slicing criterion that is a tuple $c=(x,I^{q},V)$ in which $x$ is the program input being considered, $I^{q}$ denotes the execution of statement $I$ as the $q$th statement in the path taken when $p$ is executed with input $x$, and $V$ is the set of variables of interest.

The following is the definition provided222Note that this almost exactly a quote from [15] and is taken from [37]:

Definition 9

Let $c=(x,I^{q},V)$ be a slicing criterion of a program $p$ and $T$ the trajectory of $p$ on input $x$. A dynamic slice of $p$ on $c$ is any executable program $p^{\prime}$ that is obtained from $p$ by deleting zero or more statements such that when executed on input $x$, produces a trajectory $T^{\prime}$ for which there exists an execution position $q^{\prime}$ such that

• •

(KL1) $Front(T^{\prime},q^{\prime})=DEL(Front(T,q),T(i)\not\in N^{\prime}\wedge 1\leq i\leq q)$,

• •

(KL2) for all $v\in V$, the value of $v$ before the execution of instruction $T(q)$ in $T$ equals the value of $v$ before the execution of instruction $T^{\prime}(q^{\prime})$ in $T^{\prime}$,

• •

(KL3) $T^{\prime}(q^{\prime})=T(q)=I$,

where $N^{\prime}$ is a set of instructions in $p^{\prime}$.

In producing a dynamic slice all we are allowed to do is to eliminate statements. We have the requirement that the slice and the original program produce the same value for each variable in the chosen set $V$ at the specified execution position and that the path in $p^{\prime}$ up to $q^{\prime}$ followed by using input $x$ is equivalent to that formed by removing from the path $T$ all elements not in the slice. Interestingly, it has been observed that this additional constraint, that $Front(T^{\prime},q^{\prime})=DEL(Front(T,q),T(i)\not\in N^{\prime}\wedge 1\leq i\leq q)$, means that a static slice is not necessarily a valid dynamic slice [37].

We can now give a corresponding definition for linear schemas.

Definition 10** (path-faithful dynamic slice)**

Let $S$ be a linear schema containing a label $l$, let $V$ be a set of variables and let $\rho\,l\in\mathit{pre}(\Pi(S))$ be executable. Let $S^{\prime}$ be a quotient of $S$ containing $l$. Then we say that $S^{\prime}$ is a $(\rho l,V)$-path-faithful dynamic slice (PFDS) of $S$ if the following hold.

1. (1)

Every variable in $V$ defines the same term after ${\mathit{proj}}_{S^{\prime}}(\rho)$ as after $\rho$ in $S$. 2. (2)

Every maximal path through $S^{\prime}$ which is compatible with $\rho$ has ${\mathit{proj}}_{S^{\prime}}(\rho)$ as a prefix.

If the label $l$ occurs at the end of $S$, so that $S=T\,l$ for a schema $T$, and $S^{\prime}$ is a $(\rho l,V)$-dynamic slice of $S$, so that $S^{\prime}=T^{\prime}\,l$, then we simply say that $T^{\prime}$ is a $(\rho,V)$-path-faithful dynamic end slice of $T$.

Theorem 11

Let $S$ be a linear schema, let $\rho l\in\mathit{pre}(\Pi(S))$ be executable, let $V$ be a set of variables and let $S^{\prime}$ be a quotient of $S$ containing $l$. Then $S^{\prime}$ is a $(\rho l,V)$-PFDS of $S$ if and only if ${\mathcal{M}}[\![{\rho}]\!]_{e}(v)={\mathcal{M}}[\![{{\mathit{proj}}_{S^{\prime}}(\rho)}]\!]_{e}(v)$ for all $v\in V$ and every expression $p({\mathbf{t}})=X$ which is a consequence of ${\mathit{proj}}_{S^{\prime}}(\rho)$ is also a consequence of $\rho$.

*Proof. *This follows immediately from the two conditions in Definition 10. $\;\square$

As an example of a path-faithful dynamic end slice, consider the linear schema of Figure 3. We assume that $V=\{v\}$ and the path

[TABLE]

which passes twice through the body of $p$, in each case passing through $\underline{q,{\mathsf{T}}}$, and then leaves the body of $p$. Thus the value of $v$ after $\rho$ is $f(h(u))$. Thus any $(\{v\},\rho)$-DPS $S^{\prime}$ of $S$ must contain $f$ and $h$ in order that ($1$) is satisfied, and hence contains $p$ and $q$. By Theorem 11, $S^{\prime}$ would also have to contain $g$, since otherwise $p(w)={\mathsf{F}}$ would be a consequence of ${\mathit{proj}}_{S^{\prime}}(\rho)$, whereas $p(w)={\mathsf{F}}$ is not a consequence of $\rho$. Also, $S^{\prime}$ would contain the function symbol $H$, since otherwise $q(g(w),t)={\mathsf{T}}$ would be a consequence of ${\mathit{proj}}_{S^{\prime}}(\rho)$, but not of $\rho$. Thus $S$ itself is the only $(\{v\},\rho)$-PFDS of $S$. Observe that the inclusion of the assignment $t\,{\tt{:=}}\,H(t);$ has the sole effect of ensuring that for every interpretation $i$ for which ${\pi}_{S^{\prime}}(i,e)=\rho$, ${\pi}_{S^{\prime}}(i,e)$ passes through $\underline{q,{\mathsf{T}}}$ instead of $\underline{q,{\mathsf{F}}}$ during its second passing through the body of $p$, and so deleting $t\,{\tt{:=}}\,H(t);$ does not alter the value of $v$ after ${\pi}_{S^{\prime}}(i,e)$. This suggests that our definition of a dynamic slice may be unnecessarily restrictive, and this motivates the generalisation of Definition 14.

4 A New Form of Dynamic Slicing

Path-faithful dynamic slices of schemas correspond to dynamic program slices and in order to produce a dynamic slice of a program we can produce the path-faithful dynamic slice of the corresponding linear schema. In this section we show how this notion of dynamic slicing can be weakened, to produce smaller slices, for linear schemas and so also for programs.

Consider the schema in Figure 3, the path $\rho=\,\underline{p,{\mathsf{T}}}\,\underline{g}\,\underline{f}\,\underline{q,{\mathsf{T}}}\,\underline{h}\,\underline{H}\,\underline{p,{\mathsf{T}}}\,\underline{g}\,\underline{f}\,\underline{q,{\mathsf{T}}}\,\underline{h}\,\underline{H}\,\underline{p,{\mathsf{F}}}$ and variable $v$. It is straightforward to see that a dynamic slice has to retain the predicate $p$ since it controls a statement ($u\,{\tt{:=}}\,h(u)$) that updates the value of $u$ and this can lead to a change in the value of $v$ on the next iteration of the loop. Thus, a dynamic slice with regards to $v$ and $\rho$ must retain predicate $q$. Further, the assignment $t\,{\tt{:=}}\,H(t)$ affects the value of $t$ and so the value of $q$ on the second iteration of the loop in $\rho$ and so a (path-faithful) dynamic slice must retain this assignment.

We can observe that in $\rho$ the value of the predicate $q$ on the last iteration of the loop does not affect the final value of $v$. In addition, in $\rho$ the assignment $t\,{\tt{:=}}\,H(t)$ only affects the value of $q$ on the last iteration of the loop and this assignment does not influence the final value of $v$. In this section we define a type of dynamic slice that allows us to eliminate this assignment. At the end of this section we describe a context in which we might be happy to eliminate such assignments.

Proposition 12

Let $S$ be a linear schema and let $\rho$ be a path through $S$.

1. (1)

Let $q$ be a while predicate in $S$ and let $\mu$ be a terminal path in the body of $q$ in $S$. Then a word $\alpha\underline{q,{\mathsf{T}}}\mu\underline{q,{\mathsf{F}}}\gamma$ is a path in $S$ if and only if $\alpha\underline{q,{\mathsf{F}}}\gamma$ is a path in $S$. 2. (2)

Let $q$ be an if predicate in $S$, let $Z\in\{{\mathsf{T}},{\mathsf{F}}\}$ and let $\mu,\mu^{\prime}$ be terminal paths in the $Z$-part and $\neg Z$-part respectively of $q$ in $S$. Then a word $\alpha\underline{q,Z}\mu\gamma$ is a path in $S$ if and only if $\alpha\underline{q,\neg Z}\mu^{\prime}\gamma$ is a path in $S$.

Furthermore, in both cases, one path is terminal if and only if the other is terminal.

*Proof. *Both assertions follow straightforwardly by structural induction from the definition of $\Pi(S)$ in Section 2.1. $\;\square$

Definition 13

Let $S$ be a linear schema, let $l$ be a label and let $\rho,\rho^{\prime}$ be paths through $S$. Then we say that $\rho$ is simply $l$-reducible to $\rho^{\prime}$ if $\rho^{\prime}$ can be obtained from $\rho$ by one of the following transformations, which we call simple $l$-reductions.

1. (1)

Replacing a segment $\underline{p,{\mathsf{T}}}\,\sigma\,\underline{p,{\mathsf{F}}}$ within $\rho$ by $\underline{p,{\mathsf{F}}}$, where $\sigma$ is a terminal path in the body of a while predicate $p$ which does not contain $l$ in its body. 2. (2)

Replacing a segment $\underline{p,Z}\,\sigma$ within $\rho$ by $\underline{p,\neg Z}$, where $\sigma$ is a terminal path in the $Z$-part of an if predicate $p$, $l$ does not lie in either part of $p$ and the $\neg Z$-part of $p$ is $\mathit{skip}$.

If $\rho^{\prime}$ can be obtained from $\rho$ by applying zero or more $l$-reductions, then we say that $\rho$ is $l$-reducible to $\rho^{\prime}$. If the condition on the label $l$ is removed from the definition then we use the terms reduction and simple reduction.

By Proposition 12, the transformations given in Definition 13 always produce paths through $S$. Observe that if $\rho$ is $l$-reducible to $\rho^{\prime}$, then the sequence of function and predicate symbols through which $\rho^{\prime}$ passes is a subsequence of that through which $\rho$ passes, $\rho$ and $\rho^{\prime}$ pass through the label $l$ the same number of times, and the length of $\rho^{\prime}$ is not greater than that of $\rho$.

Definition 14** (dynamic slice)**

Let $S$ be a linear schema containing a label $l$, let $V$ be a set of variables and let $\rho\,l\in\mathit{pre}(\Pi(S))$ be executable. Let $S^{\prime}$ be a quotient of $S$ containing $l$. Then we say that $S^{\prime}$ is a $(\rho l,V)$-dynamic slice (DS) of $S$ if every maximal path through $S^{\prime}$ compatible with $\rho$ has a prefix $\rho^{\prime}$ to which ${\mathit{proj}}_{S^{\prime}}(\rho)$ is $l$-reducible and such that  every variable in $V$ defines the same term after $\rho^{\prime}$ as after $\rho$ in $S$.

If the label $l$ occurs at the end of $S$, so that $S=T\,l$ for a schema $T$, and $S^{\prime}$ is a $(\rho l,V)$-dynamic slice of $S$, so that $S^{\prime}=T^{\prime}\,l$, then we simply say that $T^{\prime}$ is a $(\rho,V)$-dynamic end slice of $T$.

Consider again the schema in Figure 3 and path $\rho=\,\underline{p,{\mathsf{T}}}\,\underline{g}\,\underline{f}\,\underline{q,{\mathsf{T}}}\,\underline{h}\,\underline{H}\,\underline{p,{\mathsf{T}}}\,\underline{g}\,\underline{f}\,\underline{q,{\mathsf{T}}}\,\underline{h}\,\underline{H}\,\underline{p,{\mathsf{F}}}$. Here the quotient $T$ obtained from $S$ by deleting the assignment $t\,{\tt{:=}}\,H(t);$ is a $(\rho,v)$-dynamic end slice of $S$, since the path

[TABLE]

is simply reducible from ${\mathit{proj}}_{S^{\prime}}(\rho)$ and gives the correct final value for $v$, and $\rho^{\prime}$ and ${\mathit{proj}}_{S^{\prime}}(\rho)$ are the only maximal paths through $S^{\prime}$ that are compatible with $\rho$. This shows that a DS of a linear schema may be smaller than a PFDS.

One area in which it is useful to determine the dependence along a path in a program is in the application of test techniques, such as those based on evolutionary algorithms, that automate the generation of test cases to satisfy a structural criterion. These techniques may choose a path to the point of the program to be covered and then attempt to generate test data that follows the path (see, for example, [38, 39, 40, 41]). If we can determine the inputs that are relevant to this path then we can focus on these variables in the search, effectively reducing the size of the search space. Current techniques use static slicing but there is potential for using dynamic slicing in order to make the dependence information more precise and, in particular, the type of dynamic slice defined here.

5 A linear schema with two minimal path-faithful dynamic slices

Given a linear schema, a variable set $V$ and a path $\rho$ through $S$, we wish to establish information about the set of all $(\rho,V)$-dynamic slices, which is partially ordered by set-theoretic inclusion of function and predicate symbols. In particular, it would be of interest to obtain conditions on $S$ which would ensure that minimal slices were unique since under such conditions it may be feasible to produce minimal slices in an incremental manner, deleting one statement at a time until no more statements can be removed. As we now show, however, this is false for arbitrary linear schemas, whether or not slices are required to be path-faithful. To see this, consider the schema $S$ of Figure 4 and the slicing criterion defined by the variable $v$ and the terminal path $\rho$ which enters the body of $P$ 5 times as follows.

1st time; $\rho$ passes through $g_{good}$ and $H$, but not through either $g_{i}$.

2nd time; $\rho$ passes through $g_{good}$, $g_{1}$ and $H$, but not through $g_{2}$.

3rd time; $\rho$ passes through $g_{good}$, $g_{2}$ and $H$, but not through $g_{1}$.

4th time; $\rho$ passes through $g_{bad}$, $g_{1}$, $g_{2}$ and $H$.

5th time; $\rho$ passes through $\underline{Q,{\mathsf{F}}}$.

Define the quotient $S_{1}$ of $S$ by deleting the entire if statement guarded by $s_{2}$ and define $S_{2}$ analogously by interchanging the suffices 1 and 2. By Theorem 11, $S_{1}$ and $S_{2}$ are both $(\rho,v)$-PFDS’s of $S$, since $t(x)$ will still evaluate to ${\mathsf{T}}$ over the path ${\mathit{proj}}_{S_{1}}(\rho)$ or ${\mathit{proj}}_{S_{2}}(\rho)$ on paths 2–4. On the other hand, if the if statements guarded by $s_{1}$ and $s_{2}$ are both deleted, then on the 4th path, $t(x)$ may evaluate to ${\mathsf{F}}$, since $g_{bad}$ never occurs in the predicate term defined by $t(x)$ along $\rho$, hence the final value of $v$ may contain fewer occurrences of $H$ in the slice than after $\rho$. Furthermore, every $(\rho,v)$-DS of $S$ must contain the function symbols $J$, $H$, $G_{good}$ and $G_{bad}$ and hence $g_{good}$ and $g_{bad}$, since the final term defined by $v$ contains these symbols, and so $S_{1}$ and $S_{2}$ are minimal $(\rho,v)$-DS’s, and are also both path-faithful.

6 Decision problems for dynamic slices

In this section, we establish complexity bounds for two problems; whether a quotient $S^{\prime}$ of a linear schema $S$ is a dynamic slice, and whether a linear schema $S$ has a non-trivial dynamic slice. We consider the problems both with and without the requirement that dynamic slices be path-faithful.

Definition 15** (maximal common prefix of a pair of words)**

The maximal common prefix of words $\sigma,\sigma^{\prime}$ is denoted by $\mathit{maxpre}(\sigma,\sigma^{\prime})$. For example, the maximal common prefix of the words $x_{1}x_{2}x_{3}x_{4}$ and $x_{1}x_{2}yx_{4}$ over the five-word alphabet $\{x_{1},x_{2},x_{3},x_{4},y\}$ is $x_{1}x_{2}$; that is, $\mathit{maxpre}(x_{1}x_{2}x_{3}x_{4},x_{1}x_{2}yx_{4})=x_{1}x_{2}$.

Lemma 16

Let $S$ be a linear schema containing a label $l$ and let $\rho,\rho^{\prime}$ be paths through $S$. Suppose $\rho$ is $l$-reducible to $\rho^{\prime}$. Then there is a sequence $\rho_{1}=\rho,\ldots,\rho_{n}=\rho^{\prime}$ such that each $\rho_{i}$ is simply $l$-reducible to $\rho_{i+1}$, and $\mathit{maxpre}(\rho_{i},\rho_{i+1})$ is always a strict prefix of $\mathit{maxpre}(\rho_{i+1},\rho_{i+2})$.

*Proof. *This follows from the fact that the two transformation types commute. Since $\rho$ is $l$-reducible to $\rho^{\prime}$, there is a sequence $\rho_{1}=\rho,\ldots,\rho_{n}=\rho^{\prime}$ such that each $\rho_{i}$ is obtained from $\rho_{i-1}$ by a simple $l$-reduction, and we may assume that $n$ is minimal. Thus for each $i<n$, and using the definition of a simple $l$-reduction, we can write $\rho_{i}=\alpha_{i}\underline{p_{i},Z_{i}}\beta_{i}\gamma_{i}$ and $\rho_{i+1}=\alpha_{i}\underline{p_{i},\neg Z_{i}}\gamma_{i}$. If every $\alpha_{i}$ is a strict prefix of $\alpha_{i+1}$, then the sequence of paths $\rho_{i}$ already satisfies the required property. Thus we may assume that for some minimal $i$, $\alpha_{i}$ is not a strict prefix of $\alpha_{i+1}$.

We now compare the two ways of writing

[TABLE]

Clearly $\alpha_{i+1}$ is a prefix of $\alpha_{i}$. We consider three cases.

1. (1)

Suppose that $\alpha_{i}=\alpha_{i+1}$. Thus the first letter of $\rho_{i+1}$ after $\alpha_{i}$ is $\underline{p_{i},\neg Z_{i}}=\underline{p_{i+1},Z_{i+1}}$. If $p_{i}=p_{i+1}$ were a while predicate, then $Z_{i}={\mathsf{T}}$ would follow from the fact that $\rho_{i}$ is $l$-reducible to $\rho_{i+1}$, and $Z_{i+1}={\mathsf{T}}$ would follow similarly from the pair $\rho_{i+1},\rho_{i+2}$, giving a contradiction, hence $\,p_{i}$ must be an if predicate and so the $\neg Z_{i}$-part and the $Z_{i}=\neg Z_{i+1}$-part of $p$ is $\mathit{skip}$ from the definition of $l$-reduction and hence $\rho_{i+2}=\rho_{i}$ holds, contradicting the minimality of $n$. 2. (2)

Assume that $\alpha_{i+1}$ is a strict prefix of $\alpha_{i}$ and that $\alpha_{i}\underline{p_{i},\neg Z_{i}}$ is a prefix of

$\alpha_{i+1}\underline{p_{i+1},Z_{i+1}}\beta_{i+1}$. Thus $\underline{p_{i},\neg Z_{i}}$ occurs in $\beta_{i+1}$, and we can write

$\alpha_{i}=\alpha_{i+1}\underline{p_{i+1},Z_{i+1}}\delta_{1}$, $\,\beta_{i+1}=\delta_{1}\underline{p_{i},\neg Z_{i}}\delta_{2}$ and since $\rho_{i}$ can be obtained by replacing $\underline{p_{i},\neg Z_{i}}$ by $\underline{p_{i},Z_{i}}\beta_{i}$ after $\alpha_{i}$ in $\rho_{i+1}$,

[TABLE]

follows. By our assumption on the pair $(\rho_{i},\rho_{i+1})$, $\beta_{i}$ is a terminal path in the body or $Z_{i}$-part of $p_{i}$ and so by Proposition 12, $\delta_{1}\underline{p_{i},Z_{i}}\beta_{i}\delta_{2}$ is a terminal path in the body or $Z_{i+1}$-part of $p_{i+1}$ and so $\rho_{i+2}$ is obtainable from $\rho_{i}$ by a simple $l$-reduction, by replacing $\underline{p_{i+1},\neg Z_{i+1}}\delta_{1}\underline{p_{i},Z_{i}}\beta_{i}\delta_{2}$ by $\underline{p_{i+1},\neg Z_{i+1}}$ in $\rho_{i}$, again contradicting the minimality of $n$. 3. (3)

Lastly, assume that $\alpha_{i+1}$ is a strict prefix of $\alpha_{i}$ and that $\alpha_{i}\underline{p_{i},\neg Z_{i}}$ is not a prefix of $\alpha_{i+1}\underline{p_{i+1},Z_{i+1}}\beta_{i+1}$. Thus we can write $\alpha_{i}=\alpha_{i+1}\underline{p_{i+1},Z_{i+1}}\beta_{i+1}\,\delta$. We now change the order of the two reductions by replacing $\rho_{i+1}$ in the sequence by $\hat{\rho}_{i+1}=\alpha_{i+1}\,\underline{p_{i+1},\neg Z_{i+1}}\delta\underline{p_{i},Z_{i}}\beta_{i}\gamma_{i}$, which by two applications of Proposition 12, is a path through $S$. In effect we are replacing $\underline{p_{i+1},Z_{i+1}}\beta_{i+1}$ by $\underline{p_{i+1},\neg Z_{i+1}}$ before replacing $\underline{p_{i},Z_{i}}\beta_{i}$ by $\underline{p_{i},\neg Z_{i}}$, instead of in the original order. Since $\rho_{i+2}=\alpha_{i+1}\,\underline{p_{i+1},\neg Z_{i+1}}\delta\underline{p_{i},\neg Z_{i}}\gamma_{i}$, $\mathit{maxpre}(\rho_{i},\hat{\rho}_{i+1})$ is a strict prefix of $\mathit{maxpre}(\hat{\rho}_{i+1},\rho_{i+2})$. Thus, by the minimality of $i$, after not more than $n-i$ such replacements, the maximal common prefixes of consecutive paths in the resulting sequence will be strictly increasing in length, as required. $\;\square$

Theorem 17

Let $S$ be a linear schema, let $l$ be a label and let $\rho,\,\rho^{\prime}\in\mathit{pre}(\Pi(S))$. Then it is decidable in polynomial time whether $\rho$ is $l$-reducible to $\rho^{\prime}$.

*Proof. *By Lemma 16, $\rho$ is $l$-reducible to $\rho^{\prime}$ if and only if $\rho$ can be simply $l$-reduced to some $\rho_{2}\in\mathit{pre}(\Pi(S))$ such that $\rho_{2}$ is $l$-reducible to $\rho^{\prime}$ and $\mathit{maxpre}(\rho,\rho_{2})$ is a strict prefix of $\mathit{maxpre}(\rho_{2},\rho^{\prime})$ and hence $\mathit{maxpre}(\rho,\rho_{2})=\mathit{maxpre}(\rho,\rho^{\prime})$. Thus $\rho_{2}$ exists satisfying these criteria if and only if $\rho$ and $\rho^{\prime}$ have prefixes $\tau\sigma$ and $\tau\sigma^{\prime}$ respectively such that $\sigma^{\prime}$ is obtained from $\sigma$ by either of the transformations given in Definition 13, and $\rho_{2}$ is obtained from $\rho$ by replacing $\sigma$ by $\sigma^{\prime}$. Thus $\sigma$ can be computed in polynomial time if it exists, and this procedure can be iterated using $\rho_{2}$ in place of $\rho$. The number of iterations needed is bounded by the number of letters in $\rho^{\prime}$, thus proving the Theorem. $\;\square$

Theorem 18

Let $S$ be a linear schema containing a label $l$, let $\rho l\in\mathit{pre}(\Pi(S))$ be executable, let $V$ be a set of variables and let $S^{\prime}$ be a quotient of $S$ containing $l$.

1. (1)

The problem of deciding whether $S^{\prime}$ is a $(\rho l,V)$-path-faithful dynamic slice of $S$ lies in polynomial time. 2. (2)

The problem of deciding whether $S^{\prime}$ is a $(\rho l,V)$-dynamic slice of $S$ lies in co-NP.

*Proof. *(1) follows immediately from the conclusion of Theorem 11, since given any predicate-free schema $T$ and any variable $v$, the term ${\mathcal{M}}[\![{T}]\!]_{e}(v)$ is computable in polynomial time.

To prove (2), we proceed as follows. Any path $\rho^{\prime}l$ through $S^{\prime}$ such that $\rho^{\prime}$ is $l$-reducible from ${\mathit{proj}}_{S^{\prime}}(\rho)$ has length $\leq|{\mathit{proj}}_{S^{\prime}}(\rho)l|$. We compute a path $\tau$ through $S^{\prime}$ of length $\leq|{\mathit{proj}}_{S^{\prime}}(\rho)l|$, with strict inequality if and only if $\tau$ is terminal. This can be done in NP-time by starting with the empty path and successively appending letters to it until a terminal path, or one of length $|{\mathit{proj}}_{S^{\prime}}(\rho)l|$ is obtained. We then test whether $\tau$ is compatible with $\rho$ and does not have a prefix $\rho^{\prime}l$ through $S^{\prime}$ such that $\rho^{\prime}$ is $l$-reducible from ${\mathit{proj}}_{S^{\prime}}(\rho)$ and ${\mathcal{M}}[\![{\rho}]\!]_{e}(v)={\mathcal{M}}[\![{\rho^{\prime}}]\!]_{e}(v)$ for all $v\in V$. By Theorem 17, this can be done in polynomial time. If no such prefix exists for the given $\tau$, then no longer path through $S^{\prime}$ having prefix $\tau$ has such a prefix either, and hence $S^{\prime}$ is not a $(\rho l,V)$-dynamic slice of $S$. Conversely, if $S^{\prime}$ is not a $(\rho l,V)$-dynamic slice of $S$, then a path $\tau$ can be computed satisfying the conditions given, proving (2).

$\;\square$

Theorem 19

Let $S$ be a linear schema, let $\rho l\in\mathit{pre}(\Pi(S))$ be executable and let $V$ be a set of variables.

1. (1)

The problem of deciding whether there exists a non-trivial $(\rho l,V)$-path-faithful dynamic slice of $S$ is NP-complete. 2. (2)

The problem of deciding whether there exists a non-trivial $(\rho l,V)$-dynamic slice of $S$ lies in PSPACE and is NP-hard.

*Proof. *To prove membership in NP for Problem (1), it suffices to observe that a quotient $S^{\prime}$ of $S$ can be guessed in NP-time, and using Theorem 11, it can be decided in polynomial time whether $S^{\prime}$ is a non-trivial $(\rho l,V)$-path-faithful dynamic slice of $S$. Membership of Problem (2) in PSPACE follows similarly from Part (2) of Theorem 18 and the fact that co-NP$\subseteq$PSPACE$=$NPSPACE.

To show NP-hardness of both problems, we use a polynomial-time reduction from 3SAT, which is known to be an NP-hard problem [42]. An instance of 3SAT comprises a set $\Theta=\{\theta_{1},\ldots,\theta_{n}\}$ and a propositional formula $\alpha=\bigwedge_{k=1}^{m}\alpha_{k1}\vee\alpha_{k2}\vee\alpha_{k3}$, where each $\alpha_{ij}$ is either $\theta_{k}$ or $\neg\theta_{k}$ for some $k$. The problem is satisfied if there exists a valuation $\delta:\Theta\to\{{\mathsf{T}},{\mathsf{F}}\}$ under which $\alpha$ evaluates to ${\mathsf{T}}$. We will construct a linear schema $S$ containing a variable $v$ and a terminal path $\rho$ through $S$ such that $S$ has a non-trivial $(\rho,v)$-dynamic end slice if and only if $\alpha$ is satisfiable, in which case this quotient is also a $(\rho,v)$-path-faithful dynamic end slice. The schema $S$ is as in Figure 5.

We say that the function symbol $g_{i}$ corresponds to $\theta_{i}$ and $g_{i}^{\prime}$ corresponds to $\neg\theta_{i}$. The terminal path $\rho$ passes a total of $4+3n+6n(n-1)+m$ times through the body of $S$, and then leaves the body. The paths within the body of $S$ are of fourteen types, and are listed as follows, in the order in which they occur along $\rho$; note that only those of type (5) depend on the value of $\alpha$. The total number of paths of each type is given in parentheses at the end.

1. ([math])

2. (0.1)

$\rho$ passes through $g_{good}$, $g_{link}$, and $F_{link/reset}$, and through no other assignment apart from $H$. 2. (0.2)

$\rho$ passes through $g_{reset}$, and $F_{link/reset}$, and through no other assignment apart from $H$. 3. (0.3)

$\rho$ passes through $g_{bad}$, $g_{link}$, and $F_{link/reset}$, and through no other assignment apart from $H$.

(3 paths) 2. (1)

$\rho$ passes through $g_{good}$ and $F_{test}$, and through no other assignment apart from $H$. (1 path) 3. (2)

For each $i\leq n$, $\rho$ passes through $g_{good}$, $g_{reset}$, $g_{i}$ and $F_{test}$ and through no other assignment apart from $H$. ($n$ paths) 4. ($2^{\prime}$)​

As for type (2), but with $g_{i}^{\prime}$ in place of $g_{i}$. ($n$ paths) 5. (3)

For each $i\leq n$, $\rho$ passes through $g_{good}$, $g_{link}$, $g_{i}^{\prime}$ and $F_{test}$ and through no other assignment apart from $H$. ($n$ paths) 6. (4)

For each $i\neq j\leq n$, $\rho$ passes 3 times consecutively through the body of $S$, as follows;

1. (4.1)

The first time, it passes through $g_{good}$, $g_{reset}$, and $g_{i}$, but not through $q_{test}$ or any other assignment apart from $H$. 2. (4.2)

The 2nd time, it passes through $g_{link}$ and $g_{i}^{\prime}$, but not through $q_{test}$ or any other assignment apart from $H$. 3. (4.3)

The 3rd time, it passes through $g_{reset}$ and $g_{j}$ and $F_{test}$, but through no other assignment apart from $H$.

($3n(n-1)$ paths) 7. $(4.1^{\prime}$​​​​

$),(4.2^{\prime}),(4.3^{\prime})$ As for types (4.1),(4.2),(4.3), but with $g_{j}^{\prime}$ in place of $g_{j}$. ($3n(n-1)$ paths) 8. (5)

For each $i\leq m$, $\rho$ passes through $g_{bad}$ and $g_{reset}$, and then through the 3 function symbols corresponding to the implicants $\alpha_{i1},\alpha_{i2},\alpha_{i3}$, and then through $F_{test}$ and through no other assignment apart from $H$. ($m$ paths)

Before continuing with the proof, we first record the following facts about the terminal path $\rho$.

1. (a)

$\rho$ passes through all three assignments to $v$ and through both assignments to $b$. 2. (b)

All three assignments to $v$ in $S$ also reference $v$, and hence if there exists a terminal path $\sigma$ through any slice $T$ of $S$ such that  ${\mathcal{M}}[\![{\rho}]\!]_{e}(v)={\mathcal{M}}[\![{\sigma}]\!]_{e}(v)$, then the following hold;

1. (b0)

By (a), $T$ contains $H,\,F_{test}$, $F_{link/reset}$ and hence $g_{link}$, $g_{reset}$, $g_{good}$ and $g_{bad}$ because of the type (0) paths, and thus contains the predicates controlling these function symbols. 2. (b1)

By (a), $\sigma$ passes through all the assignments to $v$ in $S$ in the same order as $\rho$ does. 3. (b2)

$\sigma$ and $\rho$ enter the body of $p$ the same number of times, namely the depth of the nesting of $H$ in the term ${\mathcal{M}}[\![{\rho}]\!]_{e}(v)$. 4. (b3)

For any function symbol $f$ in $S$ assigning to $v$ and for all $k\geq 0$, $v$ defines the same term after the $k$th occurrence of $f$ in $\rho$ and $\sigma$, since this term is the unique subterm of ${\mathcal{M}}[\![{\rho}]\!]_{e}(v)$ containing $k$ nested occurrences of $f$ whose outermost function symbol is $f$. 5. (b4)

For any predicate $q$ in $T$ and for all $k\geq 0$, $\sigma$ and $\rho$ pass the same way through $q$ at the $k$th occurrence of $q$. For $q\not=q_{test}$, this follows from (b3) applied to $H$ or $F_{link/reset}$. For $q=q_{test}$, it follows from (b1) and (b4) applied to $Q_{test}$. 6. (b5)

${\mathit{proj}}_{T}(\rho)=\sigma$. For assume $\sigma^{\prime}\underline{q,Z}\in\mathit{pre}(\sigma)$, whereas $\sigma^{\prime}\underline{q,\neg Z}\in\mathit{pre}({\mathit{proj}}_{T}(\rho))$, where $\sigma^{\prime}\underline{q,Z}$ contains $k$ $q$’s; this contradicts (b4) immediately, and hence ${\mathit{proj}}_{T}(\rho)=\sigma$ follows from Lemma 3 and the fact that ${\mathit{proj}}_{T}(\rho)$ and $\sigma$ are both terminal paths through $T$. 3. (c)

$\rho$ never passes through the predicate terms $q_{test}(g_{bad}())$ or $q_{test}(g_{i}^{\prime}(g_{link}(g_{i}(g_{reset}()))))$. 4. (d)

For any prefix $\rho^{\prime}$ of $\rho$, the term ${\mathcal{M}}[\![{\rho^{\prime}}]\!]_{e}(v)$ does not contain any $g_{i}$ or $g_{i}^{\prime}$; for these symbols, which do not occur on the type (0) paths, assign to $x$, whereas $F_{link/reset}$, which does not occur on $\rho$ after the type (0) paths, is the only assignment to $v$ referencing a variable other than $v$.

• •

$(\Rightarrow)$. Let $T$ be a non-trivial $(\rho,v)$-DS of $S$. By (b5), $T$ is a $(\rho,v)$-PFDS of $S$ and by (b0), $T$ contains all symbols in $S$ apart possibly from some of those of the form $g_{i},g_{i}^{\prime}$ and the if predicates $q_{i},\,q_{i}^{\prime}$ controlling them. Thus it remains only to show that $\alpha$ is satisfiable.

We first show that if $T$ does not contain a symbol $g_{j}$, then for all $i\not=j$, it cannot contain both $g_{i}$ and $g_{i}^{\prime}$. Consider the type (4.3) path for the values $i,j$. If $T$ contains $g_{i}$ and $g_{i}^{\prime}$, but not $g_{j}$, then when $q_{test}$ is reached on path $(4.3)$, the predicate term thus defined, built up over paths $(4.1),(4.2),(4.3)$, is $q_{test}(g_{i}^{\prime}(g_{link}(g_{i}(g_{reset}()))))$, which does not occur along the path $\rho$, contradicting Theorem 11. By considering type $(4.3^{\prime})$ paths the same assertion holds for the symbols $g_{j}^{\prime}$. Since $T\not=S$ holds, this implies that $T$ contains at most one element of each set $\{g_{i},g_{i}^{\prime}\}$.

We now show that for each $i\leq m$, $T$ contains at least one symbol corresponding to an element in $\{\alpha_{i1},\alpha_{i2},\alpha_{i3}\}$. If this is false, then the predicate term $q_{test}(g_{bad}())$, which does not occur along the path $\rho$, would be defined on the $i$th type (5) path, contradicting Theorem 11.

Thus $\alpha$ is satisfied by any valuation $\delta$ such that for all $i\leq n$, $\,T$ contains $g_{i}$ $\Rightarrow\delta(\theta_{i})={\mathsf{T}}$ and $T$ contains $g_{i}^{\prime}$ $\Rightarrow\delta(\neg\theta_{i})={\mathsf{T}}$; since $T$ contains at most one element of each set $\{g_{i},g_{i}^{\prime}\}$, such a valuation exists.

• •

$(\Leftarrow)$. Conversely, suppose that $\alpha$ is satisfiable by a valuation $\delta:\Theta\to\{{\mathsf{T}},{\mathsf{F}}\}$, and let $T$ be the quotient of $S$ which contains each $g_{i}$ and $q_{i}$ if and only if $\delta(\theta_{i})={\mathsf{T}}$, and containing $g_{i}^{\prime}$ and $q_{i}^{\prime}$ otherwise, and contains all the other symbols of $S$. We show that $T$ is a $(\rho,v)$-DPS of $S$. By Theorem 11, it suffices to show that all predicate terms occurring along ${\mathit{proj}}_{T}(\rho)$ also occur along $\rho$ with the same associated value from $\{{\mathsf{T}},{\mathsf{F}}\}$, since by (d), ${\mathcal{M}}[\![{{\mathit{proj}}_{T}(\rho)}]\!]_{e}(v)={\mathcal{M}}[\![{\rho}]\!]_{e}(v)$.

By (d), all predicate terms occurring in ${\mathit{proj}}_{T}(\rho)$ but not $\rho$ must occur at $q_{test}$ rather than at a predicate referencing $v$. We consider each path type separately and show that no such predicate terms exist.

1. (0)

These paths do not pass through $q_{test}$. 2. (1)

${\mathit{proj}}_{T}(\rho)$ defines $q_{test}(g_{good}())$, which also occurs along $\rho$ in the type (1) path. 3. (2)

If $T$ does not contain $g_{i}$ then ${\mathit{proj}}_{T}(\rho)$ defines $q_{test}(g_{good}())$, which occurs along $\rho$ in the type (1) path. Otherwise ${\mathit{proj}}_{T}(\rho)$ defines $q_{test}(g_{i}(g_{reset}()))$, which occurs along $\rho$ in a type (2) path. 4. ($2^{\prime}$)​

Similar to type (2). 5. ($3$)

If $T$ does not contain $g_{i}^{\prime}$ then ${\mathit{proj}}_{T}(\rho)$ defines $q_{test}(g_{good}())$, which occurs along $\rho$ in the type (1) path. Otherwise ${\mathit{proj}}_{T}(\rho)$ defines $q_{test}(g_{i}^{\prime}(g_{link}(g_{good}())))$, which also occurs along $\rho$ in a type (3) path. 6. ($4$)

If $T$ contains $g_{i}$ but not $g_{j}$ or $g_{i}^{\prime}$ then ${\mathit{proj}}_{T}(\rho)$ defines $q_{test}(g_{i}(g_{reset}()))$, which occurs along $\rho$ in a type (2) path. If $T$ contains $g_{i}^{\prime}$ but not $g_{j}$ or $g_{i}$ then ${\mathit{proj}}_{T}(\rho)$ defines $q_{test}(g_{i}^{\prime}(g_{link}(g_{good}())))$, which also occurs along $\rho$ in a type (3) path. Lastly, if $T$ contains $g_{j}$ then ${\mathit{proj}}_{T}(\rho)$ defines $q_{test}(g_{j}(g_{reset}()))$, which occurs along $\rho$ in a type (2) path. 7. ($4^{\prime}$)​

Similar to type (4). 8. $(5)$

Since the valuation $\delta$ satisfies $\alpha$, for each $k\leq m$, $T$ contains at least one of the 3 function symbols corresponding to the implicants $\alpha_{k1},\alpha_{k2},\alpha_{k3}$, and hence ${\mathit{proj}}_{T}(\rho)$ defines $q_{test}(g_{i}(g_{reset}()))$ or $q_{test}(g_{i}^{\prime}(g_{reset}()))$ for some $i\leq n$, which occur along $\rho$ in a type (2) or $(2^{\prime})$ path.

Since the schema $S$ and the path $\rho$ can clearly constructed in polynomial time from the formula $\alpha$, this concludes the proof of the Theorem. $\;\square$

7 Conclusion and further directions

We have reformulated Korel and Laski’s definition of a dynamic slice of a program as applied to linear schemas, which is the normal level of program abstraction assumed by slicing algorithms, and have also given a less restrictive slicing definition. In addition, we have given P and co-NP complexity bounds for the problem of deciding whether a given quotient of a linear schema satisfies them. We conjecture that the problem of whether a quotient $S^{\prime}$ of a linear schema $S$ is a general dynamic slice with respect to a given path and variable set is co-NP-complete. Future work should attempt to resolve this.

We have also shown that it is not possible to decide in polynomial time whether a given linear schema has a non-trivial dynamic slice using either definition, assuming P$\not=$NP. It is possible that this NP-hardness result can be strengthened to PSPACE-hardness for general dynamic slices, since in this case the problem does not appear to lie in NP.

We have also shown that minimal dynamic slices (whether or not path-faithful) are not unique. Placing further restrictions on either the schemas or the paths may ensure uniqueness of dynamic slices or lower the complexity bounds proved in Section 6, and this should be investigated.

Schemas correspond to single programs/methods and so results regarding schemas cannot be directly applied when analysing a program that has multiple procedures and thus the results in this paper do not apply to inter-procedural slicing. It would be interesting to extend schemas with procedures and then analyse both dynamic slicing and static slicing for such schemas.

These results have several practical ramifications. First, since the problem of deciding whether a linear schema has a non-trivial dynamic slice is computationally hard this result must also hold for programs. A further consequence is that the problem of producing minimal dynamic slices must also be computationally hard. We also defined a new notion of a dynamic slice for linear schemas (and so for programs) that places strictly weaker constraints on the slice and so can lead to smaller dynamic slices. Finally, the fact that minimal dynamic slices need not be unique suggests that algorithms that identify and then delete one statement at a time can lead to suboptimal dynamic slices.