Results 1 
7 of
7
LambdaCalculus Schemata
, 1993
"... A lambdacalculus schema is an expression of the lambda calculus augmented by uninterpreted constant and operator symbols. It is an abstraction of programming languages such as LISP which permit functions to be passed to and returned from other functions. When given an interpretation for its constan ..."
Abstract

Cited by 100 (1 self)
 Add to MetaCart
A lambdacalculus schema is an expression of the lambda calculus augmented by uninterpreted constant and operator symbols. It is an abstraction of programming languages such as LISP which permit functions to be passed to and returned from other functions. When given an interpretation for its constant and operator symbols, certain schemata, called lambda abstractions, naturally define partial functions over the domain of interpretation. Two implementation strategies are considered: the retention strategy in which all variable bindings are retained until no longer needed (implying the use of some sort of garbagecollected store) and the deletion strategy, modeled after the usual stack implementation of ALGOL 60, in which variable bindings are destroyed when control leaves the procedure (or block) in which they were created. Not all lambda abstractions evaluate correctly under the deletion strategy. Nevertheless, both strategies are equally powerful in the sense that any lambda abstraction can be mechanically translated into another that evaluates correctly under the deletion strategy and defines the same partial function over the domain of interpretation as the original. Proof is by translation into continuationpassing style.
The WHILE Hierarchy of Program Schemes is Infinite
, 1998
"... . We exhibit a sequence Sn (n # 0) of while program schemes, i. e., while programs without interpretation, with the property that the while nesting depth of Sn is n, and prove that any while program scheme which is scheme equivalent to Sn , i. e., equivalent for all interpretations over arbitrary ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
. We exhibit a sequence Sn (n # 0) of while program schemes, i. e., while programs without interpretation, with the property that the while nesting depth of Sn is n, and prove that any while program scheme which is scheme equivalent to Sn , i. e., equivalent for all interpretations over arbitrary domains, has while nesting depth at least n. This shows that the while nesting depth imposes a strict hierarchy (the while hierarchy) when programs are compared with respect to scheme equivalence and contrasts with Kleene's classical result that every program is equivalent to a program of while nesting depth 1 (when interpreted over a fixed domain with arithmetic on nonnegative integers). Our proof is based on results from formal language theory; in particular, we make use of the notion of star height of regular languages. 1 Introduction When comparing programming languages, one often has a vague impression of one language being more powerful than another. However, a basic result of the ...
SLR Inference: An Inference System For FixedMode Logic Programs, Based On SLR Parsing
, 1994
"... ..."
Decidability of Strong Equivalence for Slices of a Class of Linear, Free, nearLiberal Program Schemas
"... A program schema defines a class of programs, all of which have identical statement structure, but whose functions and predicates may differ. A schema thus defines an entire class of programs according to how its symbols are interpreted. Two schemas are strongly equivalent if they always define the ..."
Abstract
 Add to MetaCart
A program schema defines a class of programs, all of which have identical statement structure, but whose functions and predicates may differ. A schema thus defines an entire class of programs according to how its symbols are interpreted. Two schemas are strongly equivalent if they always define the same function from initial states to final states for every interpretation. A slice of a schema is obtained from a schema by deleting some of its statements. A schema S is liberal if there exists an initial state in the Herbrand domain such that the same term is not generated more than once along any executable path through S. In this paper we introduce nearliberal schemas, in which this nonrepeating condition applies only to terms not having the form g() for a constant function symbol g. Given a schema S that is linear (no function or predicate symbol occurs more than once in S) and a variable v, we compute a set of function and predicate symbols in S which is a subset of those defined by Weiser’s slicing algorithm and prove that if for every while predicate q in S and every constant assignment w: = g(); lying in the body of q, no other
Characterizing Minimal Semanticspreserving Slices of predicatelinear, Free, Liberal Program Schemas
"... Aprogramschemadefinesaclassofprograms,allofwhichhaveidenticalstatement structure, but whose functions and predicates may differ. A schema thus defines an entire class of programs according to how its symbols are interpreted. A slice of a schema is obtained from a schema by deleting some of its state ..."
Abstract
 Add to MetaCart
Aprogramschemadefinesaclassofprograms,allofwhichhaveidenticalstatement structure, but whose functions and predicates may differ. A schema thus defines an entire class of programs according to how its symbols are interpreted. A slice of a schema is obtained from a schema by deleting some of its statements. We prove that given a schema S which is predicatelinear, free and liberal, such that the true and false parts of every if predicate satisfy a simple additional condition, and a slicing Preprint submitted to Elsevier Sciencecriterion defined by the final value of a given variable after execution of any program defined by S, theminimalsliceofSwhich respects this slicing criterion contains all the symbols ‘needed ’ by the variable according to the data dependence and control dependence relations used in program slicing, which is the symbol set given by Weiser’s static slicing algorithm. Thus this algorithm gives predicateminimal slices for classes of programs represented by schemas satisfying our set of conditions. We also give an example to show that the corresponding result with respect to the slicing criterion defined by termination behaviour is incorrect. This strengthens a recent result in which S was required to be linear, free and liberal, and termination behaviour as a slicing criterion was not considered.
Under consideration for publication in Math. Struct. in Comp. Science On the computational complexity of dynamic slicing problems for program schemas
, 2010
"... 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 prope ..."
Abstract
 Add to MetaCart
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 nontrivial dynamic slice and prove that the latter problem is NPhard 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. 1.