# Higher-Order Pattern Complement and the Strict - fp/papers/ Higher-Order Pattern Complement

date post

12-Dec-2018Category

## Documents

view

213download

0

Embed Size (px)

### Transcript of Higher-Order Pattern Complement and the Strict - fp/papers/ Higher-Order Pattern Complement

Higher-Order Pattern Complement and the Strict-Calculus

ALBERTO MOMIGLIANO

University of Leicester

and

FRANK PFENNING

Carnegie Mellon University

We address the problem of complementing higher-order patterns without repetitions of existential

variables. Differently from the first-order case, the complement of a pattern cannot, in general,

be described by a pattern, or even by a finite set of patterns. We therefore generalize the simply-typed -calculus to include an internal notion of strict function so that we can directly express

that a term must depend on a given variable. We show that, in this more expressive calculus, finitesets of patterns without repeated variables are closed under complement and intersection. Our

principal application is the transformational approach to negation in higher-order logic programs.

Categories and Subject Descriptors: D.3.3 [Programming Languages]: Language Constructs

and Features; D.1.6 [Programming Techniques]: Logic Programming; F.4.1 [MathematicalLogic and Formal Language]: Mathematical LogicLambda calculus and related systems

General Terms: Languages, Theory

Additional Key Words and Phrases: Complement, higher-order patterns, strict -calculus

1. INTRODUCTION

In most functional and logic programming languages the notion of a pattern, to-gether with the requisite algorithms for matching or unification, play an importantrole in the operational semantics. Besides unification, other problems such as gen-eralization or complement also arise frequently. In this paper we are concerned withthe problem of pattern complement in a setting where patterns may contain bind-ing operators, so-called higher-order patterns [Miller 1991; Nipkow 1991]. Higher-order patterns have found applications in logic programming [Miller 1991; Pfenning1991a], logical frameworks [Despeyroux et al. 1997], term rewriting [Nipkow 1993],and functional logic programming [Hanus and Prehofer 1996]. Higher-order pat-

Authors addresses:A. Momigliano, Department of Mathematics and Computer Science, University of Leicester, Le-

icester, LE1 HR2, U.K., am133@mcs.le.ac.ukF. Pfenning, Department of Computer Science, Carnegie Mellon University, Pittsburgh, PA 15213,

U.S.A., fp@cs.cmu.eduThis work has been support by the National Science Foundation under grant CCR-9988281.

Permission to make digital/hard copy of all or part of this material without fee for personalor classroom use provided that the copies are not made or distributed for profit or commercial

advantage, the ACM copyright/server notice, the title of the publication, and its date appear, andnotice is given that copying is by permission of the ACM, Inc. To copy otherwise, to republish,

to post on servers, or to redistribute to lists requires prior specific permission and/or a fee.c 20?? ACM 1529-3785/20??/0700-0001 $5.00

ACM Transactions on Computational Logic, Vol. ?, No. ?, ? 20??, Pages 137.

2 A. Momigliano and F. Pfenning

terns inherit many pleasant properties from the first-order case. In particular, mostgeneral unifiers [Miller 1991] and least general generalizations [Pfenning 1991b] ex-ist, even for complex type theories.

Unfortunately, the complement operation does not generalize as smoothly. Lugiez[1995] has studied the more general problem of higher-order disunification and hadto go outside the language of patterns and terms to describe complex constraints onsets of solutions. We can isolate one basic difficulty: a pattern such as x. E x for anexistential variable E matches any term of appropriate type, while x. E matchesprecisely those terms x. M where M does not depend on x. The complementthen consists of all terms x. M such that M does depend on x. However, this setcannot be described by a pattern, or even a finite set of patterns.

This formulation of the problem suggests that we should consider a -calculuswith an internal notion of strictness so that we can directly express that a termmust depend on a given variable. For reasons of symmetry and elegance we alsoadd the dual concept of invariance expressing that a given term does not dependon a given variable. As in the first-order case, it is useful to single out the case oflinear patterns, namely those where no existential variable occurs more than once.1

We further limit attention to simple patterns, that is, those where constructorsmust be strict in their argumentsa condition naturally satisfied in our intendedapplication domains of functional and logic programming. Simple linear patternsin our -calculus of strict and invariant function spaces then have the followingproperties:

(1) The complement of a pattern is a finite set of patterns.

(2) Unification of two patterns is decidable and finitary.

Consequently, finite sets of simple linear patterns in the strict -calculus are closedunder complement and unification. If we think of finite sets of linear patterns asrepresenting the set of all their ground instances, then they form a boolean algebraunder set-theoretic union union, intersection (implemented via unification) and thecomplement operation.

The paper is organized as follows: Section 2 briefly reviews related work and in-troduces some preliminary definitions. In Section 3 we introduce a strict -calculusand prove some basic properties culminating in the proof of the existence of canoni-cal forms in Section 4. Section 5 introduces simple terms, followed by the algorithmfor complementation in Section 6. In Section 7 we give a corresponding unificationalgorithm. Section 8 observes how the set of those patterns can be arranged in aboolean algebra. We conclude in Section 9 with some applications and speculationson future research.

2. PRELIMINARIES AND RELATED WORK

A pattern twith free variables can be seen as a representation of the set of its groundinstances, denoted by t. According to this interpretation, the complement of t isthe set of ground terms that are not instances of t, i.e., the terms are in the set-theoretic complement of t. It is natural to generalize this to finite sets of terms,

1This notion of linearity should not be confused with the eponymous concept in linear logic and

-calculus.

ACM Transactions on Computational Logic, Vol. ?, No. ?, ? 20??.

Higher-Order Pattern Complement 3

where t1, . . . , tn = t1 tn. If we take this one step further we obtainthe important problem of relative complement ; this corresponds to computing asuitable representation of all the ground instances of a given (finite) set of termswhich are not instances of another given one, written as t1, . . . , tnu1, . . . , um.

Complement problems have a number of applications in theoretical computer sci-ence (see Comon [1991] for a list of references). For example, they are used in func-tional programming to produce unambiguous function definitions by patterns andto improve their compilation. In rewriting systems they are used to check whetheran algebraic specification is sufficiently complete. They can also be employed toanalyze communicating processes expressed by infinite transition systems. Otherapplications lie in the areas of machine learning and inductive theorem proving. Inlogic programming, Kunen [1987] used term complement to represent infinite setsof answers to negative queries. Our main motivation has been the explicit synthe-sis of the negation of higher-order logic programs [Momigliano 2000a; 2000b], asdiscussed briefly in Section 9.

Lassez and Marriot [1987] proposed the seminal uncover algorithm for comput-ing first-order relative complements and introduced the now familiar restriction tolinear terms. We quote the definition of the Not algorithm for the (singleton)complement problem given in [Barbuti et al. 1990] which we generalize in Defini-tion 6.1. Given a finite signature and a linear term t they define:

Not(x) = Not(f(t1, . . . , tn)) = {g(x1, . . . , xm) | g and g 6= f}

{f(z1, . . . , zi1, s, zi+1, . . . , zn) | s Not(ti), 1 i n}

The relative complement problem is then solved by composing the above comple-ment operation with term intersection implemented via first-order unification.

An alternative solution to the relative complement problem is disunification (see[Comon 1991] for a survey and [Lugiez 1995] for an extension to the simply-typed-calculus). Here, operations on sets of terms are translated into conjunctionsor disjunctions of equations and dis-equations under explicit quantification. Non-deterministic application of a few dozen rules eventually turns a given problem intoa solved form. Though a reduction to a significant subset of the disunification rulesis likely to be attainable for complement problems, control is a major problem. Weargue that using disunification for this purpose is unnecessarily general. Moreover,the higher-order case results in additional complications, such as restrictions on theoccurrences of bound variables, which fall outside an otherwise clean framework.As we show in this paper, this must not necessarily be the case. We believe thatour techniques can also be applied to analyze disunification, although we have notinvestigated this possibility at present.

We now introduce some preliminary definitions and examples which guide ourdevelopment. We begin with the simply-typed -calculus. We write a for atomictypes, c for term-level constants, and x for term-level variables. Note that variablesx should be seen as parameters and not subject to instantiation.

ACM Transactions on Computational Logic, Vol. ?, No. ?, ? 20??.

4 A. Momigliano and F. Pfenning

Simple Types A ::= a | A1 A2Terms M ::= c | x | x:A. M |M1 M2

Signatures ::= | , a:type | , c:ACont

Recommended

*View more*