express that the arguments have not the shape required by the normal rules. The default rules also impose universal quantications over the free variab

Transcription

1 Default Rules: An Extension of Constructive Negation for Narrowing-based Languages Juan Jose Moreno-Navarro U. Politecnica, Facultad de Informatica, Campus de Montegancedo, Boadilla del Monte, Madrid, Spain, Abstract In this paper an extension of narrowing-based functional logic languages is proposed: Every partial denition of a function can be completed with a default rule. In a concrete function call, the default rule is applicable when the normal ones determine that they cannot compute the value of the call. The use of the default rule, in the presence of a goal with variables, is constructive. The operational semantics provides constraints to the variables to make the default rule applicable. Narrowing semantics are modied extending the technique of constructive negation [3, 4, 17]. 1 Introduction Narrowing is a unication based parameter passing mechanism which subsumes rewriting and SLD resolution. Dierent versions of narrowing have been used as the operational semantics of programming languages. In particular, so called functional logic languages retain functional syntax but use narrowing as operational semantics. They have been proposed to combine the functional and logic programming paradigms. As in pure functional programming, the functions dened by the program can be partially dened. A computation fails when a function call cannot be solved. "Exceptions" (see [14] for their use in ML) allows to handle these cases, giving, for instance, a default value. However this solution is not so easy to achieve in the case of functional logic languages because the logical component of the language allows to search values for applying the function. The default value can be returned only if the other rules cannot apply what imposes some constraints on the calling parameters. The denition of partial functions is implicitly used in PROLOG to carry out negation. Under the Closed World Assumption (CWA) a predicate p is f alse for all the tuples which are not positively dened by the clauses of p. In this paper we extend this notion of completion for a functional logic language. Every (partial) denition of a function with a number of rules can be completed by an extra default rule. The default rule establishes the function value for all the tuples that are not nitely dened by the previous rules. In particular we have incorporated the default value feature to BABEL [15] with disequality constraints over the Herbrand Universe [10], resulting a new language called Def-BABEL. However, it is clear that the techniques are independent of the chosen narrowing based language. In order to manage default rules, symbolic constraints are needed to

2 express that the arguments have not the shape required by the normal rules. The default rules also impose universal quantications over the free variables of the normal rules. The operational mechanism is a natural extension of constructive negation proposed for PROLOG [3, 4, 17] which incorporates constraints as the answers into negative subgoals. The narrowing mechanism can be adapted to compute default values: in order to detect if a function call f (e 1 ; : : : ; e n ) is dened we start a narrowing computation with f (e 1 ; : : : ; e n ) as goal. Any frontier of this computation denes where the expression is dened, hence the complement of this frontier denes where it is undened. The paper also includes the formal meaning of these default rules by dening the declarative semantics of Def-BABEL programs. The domain distinguishes between nite failure and the? value, which denotes divergence, in the style of Kunen's 3-valued semantics [11]. This semantics allows us to express soundness and completeness results. 2 A Functional Logic Language with Default Rules This section denes Def-BABEL programs and gives some examples. We assume a ranked set T C = [ n2in T C n of type constructors (e.g. nat=0; list=1) and a countably innite set TVar of type variables ;, etc. (denoted in programs by capital letters). Any algebraic term built from type constructors and type variables { e.g. list(nat); list() { is a data type. A data type is polymorphic if it includes type variables, and monomorphic otherwise. We also assume a set DC of data constructors d=n with declared principal types: d : 1 : : : n!, e.g. s: nat! nat. In practice, type constructors and data constructors can be introduced through type declarations and some types like list, nat or bool = truejf alse are assumed to be predened. Next, we assume a countably innite set VS of (typed) data variables (denoted by capital letters) and a set FS of function symbols f =n with declared principal types: f : 1 : : : n!, for example subs : nat nat! nat. Terms t and expressions e are dened as follows: e ::= X t ::= X % X 2 V S j d (t 1 ; ::; t n ) % d=n 2 DC j d (e 1 ; ::; e n ) % d=n 2 DC j f (e 1 ; ::; e n ) % f 2 F S and all of them must be well typed (following Milner's type system). The syntax allows to build expressions involving some primitive function symbols: :b (negation), (b 1 ; b 2 ) (conjunction), (b 1 ; b 2 ) (disjunction), (b! e) (guarded expression, meaning: if b then e else undened), (b! e 1 2e 2 ) (conditional, meaning: if b then e 1 else e 2 ), and (e 1 = e 2 ) (weak equality, both expressions denote the same object), where b is a boolean expression. BABEL programs consist of declarations of types and dening or default rules for every function symbol f : 1 : : : n!, with the following shape, where guards are optional: f (t 1 ; : : : ; t n ) {z } left hand side Dening rules := fb!g {z } guard e {z} body {z } right hand side Default rules default f (X 1 ; : : : ; X n ) := b! e

3 BABEL functions are functions in the mathematical sense. In order to ensure conuence, some syntactical restrictions are imposed: 1. Data Patterns and Left Linearity: t i 's are terms and every lhs does not contain multiple variable occurrences. 2. Restrictions on free variables: Variables occurring in the rhs but not in the lhs are only allowed in the guard. 3. Well Typedness: It must be possible to check the types i for each t i (1 i n), the type bool for b, and the type for e. 4. Nonambiguity: Given two dierent dening rules in the same function, either their left hand sides are not uniable or if the lhs's unify with m.g.u., after applying to both bodies, either they are identical or their guards are incompatible 1. Now, we can intuitively dene the meaning of a function denition. The left column shows a set of function rules and the right column their meaning: f(t 1 (X 1 )) := b 1 (X 1 ; Y 1 )! e 1 : : : f(t n (X n )) := b n (X n ; Y n )! e n default f(x) := b(x; Y )! e 8 >< f(z) = >: e 1 if 9X 1 (Z = t 1 ^ 9 Y 1 b 1 )... e n if 9X n (Z = t n ^ 9 Y n b n ) e if 9Y b ^ (f(z)) where is the denitionless operator that means that the dening rules for f do not dene f (Z). Example 2.1 The following program computes the substraction of natural numbers. The partially dened version is completed with a default rule in order to return an integer. Integers are dened as signed numbers. type nat := 0 j s(nat). fun subs : nat nat! int. type int := + nat j { nat. subs (Y, 0) := + Y. fun invert: int! int. subs (s (Y),s (X)) := subs (Y, X). invert(+ Y) := { Y. default subs (Y, X) := invert({ Y) := + Y. invert (subs (X, Y)). eval subs (s (0), X). > result + s (0) answer X = 0 > result + 0 answer X = s (0) > result { X' answer X = s (X'), X' 6= 0 > no (more) solutions. Example 2.2 The second example involves variable quantication. A natural number is even if it is the double of another natural number. Otherwise the number is odd. This last statement correspond to a default rule which involves an implicit universal quantication. type list A := []j[ajlist A]. fun plus: nat nat! nat. type parity type := evenjodd. plus (0, Y) := X. fun <: nat nat! bool. plus (s (X), Y) := s (plus (X, Y)). % Some rules for <. fun parity: nat! parity type. parity (X) := (Y < X, plus (Y, Y) = X)! even. default parity (X) := odd. 1 Incompatibility [10] is a decidable syntactical property between two boolean expressions in order to ensure that they cannot be simultaneously reduced to true.

4 eval [parity (1), parity (2), parity (3), parity (4)]. > result [odd, even, odd, even] > no (more) solutions. 3 Declarative Semantics of Default Rules This section is devoted to the declarative semantics of Def-BABEL. Since pure BABEL is a subset of our language some technical details (present in [15]) will be skipped or simplied. We start with the denition of the domain. Polymorphism is treated in the simplest way: every polymorphic function is replicated for each particular monomorphic application. Denition 3.1 Herbrand Universe H is the correctly typed Herbrand universe built up with the constructors of the types dened in the program These terms are called concrete elements. We also add to H two values for failure: f ail (to indicate nite failure) and? (for divergence). We assume the following ordering in H? v d for every d fail v d for every concrete element d Notice the similarities between our model and Kunen's 3-valued semantics [11]. However, our semantics needs two values for failure because f alse is a correct result for functions and predicates. Now we proceed with the denition of interpretations. Denition 3.2 Interpretations and environments A Herbrand interpretation I is a collection of well typed monotonic functions f I : H n! H, one for every function f =n in F S such that f I (?) =? and f I (f ail) = f ail. Interpretations can be equipped with the partial ordering: I v J i for all f=n 2 F S f I (s) v f J (s) for all s 2 H n The domain of Herbrand interpretations is noted H?IN T. An environment is any mapping : V S! H? ff ail;?g such that (X) has the same type of the variable X. Now, we just can dene the valuation [e] I () for a given well typed expression e into a concrete interpretation I under an environment by induction on the syntactical structure of the expression. Denition 3.3 Valuation [X ] I () = (X) for X 2 V S [d (e 1 ; ::; e n )] I () = d ([e 1 ] I (); ::; [e n ] I ()) for d=n 2 CS; n 0 [f (e 1 ; ::; e n )] I () = f I ([e 1 ] I (); ::; [e n ] I ()) for f=n 2 F S; n 0 [e 1 = e 2 ] I () = eq([e 1 ] I (); [e 2 ] I ()) [:b] I () = not([b] I ()) [b 1 ; b 2 ] I () = and([b 1 ] I (); [b 2 ] I ()) [b 1 ; b 2 ] I () = or([b 1 ] I (); [b 2 ] I ()) [b! e] I () = if([b] I (); [e] I ()) [b! e 1 2e 2 ] I () = if else([b] I (); [e 1 ] I (); [e 2 ] I ()) where the semantics functions and, not, or, if, if else, and eq are dened as follows:

5 and? f ail false true????? fail? fail fail fail false? f ail false false true? f ail false true not?? fail fail false true true false 8 s >< fail if(b; s) = >: or? f ail false true????? fail? fail fail fail false? f ail false true true? f ail true true 8 true if s >< 1 ; s 2 concrete ^ s 1 = s 2 false if s 1 ; s 2 concrete ^ s 1 6= s 2 eq(s 1 ; s 2 ) = fail if s >: 1 = s 2 = fail? otherwise if b = true if b = false or b = fail? otherwise 8 s >< 1 if b = true s 2 if b = false if else(b; s 1 ; s 2 ) = fail if b = fail >:? otherwise Knowing how to evaluate expressions, any dening rule can be interpreted as the statement whose value for the lhs is always as least as dened as the rhs value. To formally dene the meaning of a default rule we need some auxiliary denitions: Denition 3.4 Denitionless function Given a function f =n, a program, and a Herbrand interpretation I we dene the functions T I (f); TI b (f) : H n! P(H) as follows: T I (f)(s 1 ; ::; s n ) = f[r ] I ()=f (t 1 ; ::; t n ) := R 2 ; (t i ) = s i g bt I (f)(s 1 ; ::; s n ) = f[r ] I ()=defaultf (t 1 ; ::; t n ) := R 2 ; (t i ) = s i g where is an environment. We also dene the denitionless function I (f) : H n! bool such that 8 < I (f)(s) = : if T I (f)(s) = ; or T I (f)(s) = ffailg true? if? 2 T I (f)(s) f alse otherwise. The function establishes where the function f has not a denition using the dening rules. Notice that the denitions of T I and involve some implicit universal quantication if a dening rule contains free variables in the guard. Now, we can dene when an interpretation is a model of a program. Denition 3.5 Models An interpretation I is a model of a program (in symbols I j= ) if a).- I is a model of every dening rule in, and b).- for every default rule f (X 1 ; : : : ; X n ) := e in f I ((X)) = [e] I () if I (f)((x)) = true for any environment. I is a Herbrand model of a dening rule L := R i [L] I () w [R] I () for all environments. We can prove now the existence of a least Herbrand model for any given program. As it is done in classical logic programming, minimal models are obtained as least xpoints of monotonic interpretation transformers.

6 Denition 3.6 The interpretation transformer associated to is the mapping T : H?IN T! H?IN T dened as follows: for any interpretation I, T (I) is the Herbrand interpretation J such that for any f =n 2 F S and well typed elements s 1 ; : : : ; s n 2 H 8 < f J (s) = : m if m = fail where n if I (f)(s) = true m = max T I (f)(s)? otherwise n = max TI b (f)(s) Proposition 3.1 T is well dened and monotonic. Proof: T is well dened as an immediate consequence of the conuence property, syntactically established. As the set T I (f)(s) can only have a single concrete value, then the maximum exists. Monotonicity can be easily proven from the denition of the transformer. The distinction between f ail and? means the key point in the proof. The unknown values are denoted by? and they cannot be used in a default rule. Only when a nite failure is calculated the value f ail is used and the default rules can be applied. The main result of the declarative semantics establishes the existence of a least Herbrand model I for every BABEL program. It is deduced from Proposition 3.1 by using the well known Tarski's theorem. Theorem 3.1 There exists a least xpoint I of T, that can be computed as the limit of the sequence I 0 = I? and I i+1 = T (I i ) where I? is the interpretation that assigns? as denotational value for every function. Moreover, I is the least Herbrand model in H?IN T. Once the existence of I has been proven, some of the denitions for interpretations can be instantiated for it. In particular we will call, simply, to the function I. We will also use the complement of this function, called. Intuitively (f (e 1 ; : : : ; e n )) means that the expression f (e 1 ; : : : ; e n ) is positively dened, i.e. can be calculated without the default rule. More formally: (f (s)) = not (f)(s) 4 Operational Semantics For simplicity of presentation, we restrict ourselves to an innermost version of narrowing working with symbolic constraints. In order to provide a stepwise denition for all the concepts we will rst present how innermost narrowing works with constraints. In the next subsection the denition of innermost narrowing will be extended in order to cope with default rules. The main idea is to obtain the function syntactically. Finally we will describe the simplication of symbolic constraints. 4.1 Innermost Narrowing with Constraints over the Herbrand Universe A computation involves a constraint c and an expression e. The constraint c contains equalities and disequalities of terms. The equalities collected into

7 the constraint can be seen as the substitutions in usual narrowing, similarly as it is done within the CLP scheme [9]. A more abstract and general description of the operational semantics of the constraint functional logic programming paradigm can be found in [12]. To obtain a formal denition of BABEL's innermost narrowing semantics we need a notion of expression normal form (nf): the canonical representation of values. We say that an expression e is in nf i e is a variable X, e is a nullary constructor d, or e is of the form d(e 1 ; ::; e m ), where d=n 2 DC and e 1 ; ::; e m are in nf Moreover, we need a notion of normal form also for constraints. A disequation d(x; a) 6= d(b; Y ) implies a disjunction X 6= b _ Y 6= a. So, we use conjunctions of disjunctions of disequations as normal forms. On the other hand, we will produce disequations by means of the negation of an equation X = t(y ). This fact produces the universal quantication of the free variables Y, unless a more external quantication aects them. The negation of such equation is 8Y X 6= t(y ). Also, universally quantied disequations are allowed in the constraints. More precisely, the normal form of constraints is: ^ (X i = t i ) ^ 8 Z 1 j {z } (Y j 1 6= s1 j ) ^ : : : ^ 8 Zj n (Y l n 6= s n l ) j l positive information {z } negative information where each X i appears only in X i = t i, none s r r k is equal to Yk and the universal quantication could be empty (leaving a simple disequality). The notation c ` c 0 indicates that the constraint c 0 is the simplication (normal form) of c. c ` f alse means that the constraint c is unsatisable. The rules for ` will be presented in subsection 4.3. The one step narrowing relation is denoted c [] e =) c 0 [] e 0, where c' is not f alse. It is specied by the following rules 2 : 1. Rule application c [] f (e 1 ; : : : ; e n ) =) c 0 [] e 0 if e 1 ; : : : ; e n are in nf, there is a variant f (t 1 ; : : : ; t n ) := fb!ge of one rule in the program (sharing no variables with the goal) such that f (t 1 ; : : : ; t n ) and f (e 1 ; : : : ; e n ) are uniable with m.g.u. = in _[ out (where in collects the bindings for variables in the t i and out records the bindings for variables in the e i ), and e 0 is (fb!ge) in c ^ V(X i = s i ) ` c 0, where out = f: : : ; X i =s i ; : : :g c 2. Inner narrowing step [] e i =) c 0 [] e 0 i c [] k(e 1 ; ::; e i ; ::; e n ) =) c 00 [] k(e 1 ; ::; e 0 i ; ::; e n) if k=n 2 DC [ F S; 1 i n and c ^ c 0 ` c Rules for guards and conditionals c [] b =) c 0 [] b 0 c [] (true! e) =) c [] e c [] (true! e 1 2 e 2 ) =) c [] e 1 c [] (false! e 1 2 e 2 ) =) c [] e 2 c [] (b!e)=) c 00 [] (b 0!e) if b is not in nf and c ^ c 0 ` c 00 c [] b=)c [] b 0 c [] (b!e 1 2e 2 )=) c 00 [] (b 0!e 1 2e 2 ) if b is not in nf, c ^ c 0 ` c 00 2 The rules assume that the condition holds, i.e. the resulting constraint is not f alse

8 4. Rules for the equality c [] (e 1 = e 2 ) =) c 0 [] true if e 1 ; e 2 are in nf, and c ^ (e 1 = e 2 ) ` c 0 c [] (e 1 = e 2 ) =) c 0 [] false if e 1 ; e 2 are in nf, and c ^ (e 1 6= e 2 ) ` c 0 c [] e 1 =) c 0 [] e 0 1 c [] (e 1 = e 2 ) =) c 00 [] (e 0 1 = e 2) if e 1 is not in nf and c ^ c 0 ` c 00 c [] e 2 =) c 0 [] e 0 2 c [] (e 1 = e 2 ) =) c 00 [] (e 1 = e 0 2 ) if e 2 is not in nf and c ^ c 0 ` c 00 The rest of the primitive functions can be computed by some predened rules (see [15]) or, alternatively, by including some explicit narrowing rules. It allows to have a lazy (short-circuit) denition of the logical connectives. The notation c [] e c 0 [] e 0 =) : : : c i [] e i : : : =) c n [] e n c 0 [] e 0, or simply c [] e =) c 0 [] e 0 denotes the narrowing relation (composition of several narrowing steps). There is some degree of freedom in the previous scheme. A redex is the point where one of the previous rules is applicable. The selected expression to be reduced into a construction (rule 2) or an equality (rule 4) should be xed by a computation rule R. The usual implemented rule is the selection of the left-most redex that it is not yet in normal form. However, this is not the only cause of nondeterminism: several applicable rules for a given expression could be done. Denition 4.1 Children and Narrowing Tree Given a constraint expression c [] e, a program and a computation rule R we call any possible application of the one step narrowing relation guided by R a child of c [] e on. All the possible narrowing reductions of a constraint expression c [] e given a program and a computation rule R form the narrowing tree for c [] e. Every node is labelled with a constraint expression 3. Performing narrowing with a BABEL goal expression c [] e may lead to several situations, which classify the paths into the narrowing tree: Success: c [] e =) c 0 [] t with t 2 Term and c 0 satisable. Failure: c [] e =) c 0 [] e 0, e 0 62 Term and e 0 is not further narrowable or c 0 unsatisable. Nontermination: In this case we may still have c [] e =) c 0 [] e 0 where e 0 62 Term and e 0 's constructors give a partial result. When a succesful narrowing relation reaches a term c 0 [] t we speak of a computation for the goal c [] e with result t and answer c 0. A very important notion for our purpose is the concept of frontier of a narrowing tree. 3 In the following we will omit the reference to the program and the computation rule R when no ambiguity is possible.

9 Denition 4.2 Frontier A frontier of c [] e is a nite set of nodes of the narrowing tree such that every narrowing reduction of c [] e is either a failure or passes through exactly one node in the set. We will denote a frontier F as a set fc 1 [] e 1 ; : : : ; c m [] e m g. Example 4.1 A frontier of the expression true [] subs(s(0); X) in example 1.1 could be fx = 0 ^ Y = s(0) [] + s(0); Y = 0 ^ X = s(x 0 ) [] subs(0; X 0 )g following the narrowing tree: true [] subs(s(0); X) 9 X XX X XXz X = 0 ^ Y = s(0) [] + s(0) Y = 0 ^ X = s(x 0 ) [] subs(0; X 0 ) 4.2 Narrowing for default rules The next step is the computation of default rules. The main idea is to manage the function syntactically. However, let us remember that the semantical denition of the function includes an implicit universal quantication. They are moved to explicit 8-quantications. We will work with expressions of the form 8 X (c [] e) (where c [] e is a constraint expression) that must be read \under the constraint c, e is undened using the dening rules". In the previous section we have dened how an expression is computed with the dening rules by using narrowing. We can narrow the expression in every possible way until we get all the solutions and then we can negate them. This yields to a condition that is equivalent to the function. However, the narrowing tree could be innite and the process will not terminate. An eective solution consists of the use of a frontier of the narrowing tree (which is always nite) to produce a condition equivalent to the function. The process is based in the following result: Proposition 4.1 If is a BABEL program and F = fc 1 [] e 1 ; : : : ; c n [] e n g is a frontier of c [] e then (c [] e) $ 9 X 1 (c 1 ^ (e 1 )) _ : : : _ 9 X n (c n ^ (e n )) where X i are the free variables in c i [] e i which are not in c [] e. As the function is the negation of the function, this result can be used to calculate a expression by the negation of the right hand side formula. The notion of complement of a frontier is used for this purpose. Denition 4.3 Complement of a frontier Let F = fc 1 [] e 1 ; : : : ; c n [] e n g be the frontier of a constraint expression c [] e and V a set of variables (denoting the free variables in the goal expression). The complements of F under V are all the possible conjunctions of complements of each c i [] e i under V : c 0 1 ^ : : : ^ c0 m [] b 1 ; : : : ; b m is a complement of F i each c 0 i [] b i is a complement of c i [] e i under V.

10 In order to dene the complement of a constraint expression c [] e, let us briey discuss the quantication of variables. First, we only need to focus on those useful variables, i.e. those that are free in the goal expression. We collect them in the set V. A variable X appearing in the positive part of the constraint as X = t can be eliminated. If t is a variable X 0 2 V we substitute X for X 0 in c [] e. Otherwise, the equation is irrelevant. Next, we identify the variables that will have a universal quantication when the complement is calculated. They are the free variables in e that are neither in V nor in the positive part (that have an implicit quantication). We collect them in the set U. The disjunction of inequalities with variables in U cannot be separated from e. The rest of the disjunctions can be negated separately from e. When a disjunction of disequalities is negated it is moved into a conjunction of equalities. These equalities have not quantication even if the original disequation are not quantied because the free variables are (implicitly) quantied outside. In summary, we can organize the simplication of c as: c = m^ (X i = t i ) ^ i=1 n^ n _ j j=1 k=1 8 Z j k (Y j k 6= sj k ) ^ c0 where c 0 collects all the inequalities with a variable in U. Denition 4.4 Complements of a constraint expression The complements of c [] e under V are: W m 8 1=1 Z i (X i 6= t i ) [] true, where Z i are the variables of t i that are not quantied outside, i.e. var(t i ) \ V. V m i=1 (X i = t i ) ^ Vn l k=1 (Y l k = s k l ) ^ Vl?1 j=1 all l < n. V m i=1 (X i = t i ) ^ Vn variables in U. j=1 W nj 8 k=1 Zj k (Y j k 6= sj k ) [] true, for W nj k=1 8 Zj k (Y j k 6= sj k ) [] 8 Z (c0 [] e), where Z are the The last component in the denition 4.4 includes the computation of the denitionless operation. This -expression can be simplied when the expression e is a constructor application or a predened function. Due to the lack of space we omit some rules for the simplication. Some examples are: 8 X (c [] :b) 8 X (c [] b), 8 X (c [] (b! e)) (c [] b); 8 X (c [] b! e2true), if X is empty or they appear only in e, or 8 X (c [] (e 1 = e 2 )) 8 X (c [] e 1 ); 8 X (c [] e 2 ). The simplication rules try to minimize the computational eort. For instance, in the case of the equality the rule avoids to compute the real value of the equality and it just computes the denitionless operation of both expressions. Usually a very big expression generates a complicate search space, and it is better to consider the denitionless of the subexpressions one by one. Example 4.2 In order to compute the complement of the frontier of example 4.1, the complement of each constraint expression of the frontier is computed. X is the single goal variable, so the equations for the variable Y are eliminated.

11 The complements of X = 0 [] + s(0) are: X 6= 0 [] true and X = 0 [] (true [] + s(0)) but the second one is equivalent to f alse after applying -simplication rules. The complements of X = s(x 0 ) [] subs(0; X 0 ) are: 8 X 0 X 6= s(x 0 ) [] true and X = s(x 0 ) [] (true [] subs(0; X 0 )). Finally, the complements of the frontier of true [] subs(s(0); X) are obtained by combining the previous complements: 1. X 6= 0 [] true; 8 X 0 (X 6= s(x 0 ) [] true 2. X 6= 0 [] true; X = s(x 0 ) [] (subs(0; X 0 ) As we will see, the rst expression yields to a constraint that is unsatisable in the domain of the natural number and will be discarded. Now, we complete the narrowing rules to use the default rule (if present) and to compute a (c [] e) expression. The new rules are: (c [] f (e 5. Default rule 1 ; : : : ; e n ) =) c 0 [] true c [] f (e 1 ; : : : ; e n ) =) c 00 [] e where default f (X 1 ; : : : ; X n ) := e 2 and e 1 ; : : : ; e n are in nf, = f::; X i =e i ; ::g and c ^ c 0 ` c Denitionless expressions rule Let F be a frontier of the narrowing tree of c [] e using rules 1,..., 4 for the rst step, and let V be the set of free variables of c [] e that are not in X. 8 X (c [] e) =) true if F = ; 8 X (c [] e) =) c [] b if F 6= ; and (c [] b) is a complement of F under V For each complement of F we have a dierent child in the narrowing tree. 4.3 Management of symbolic constraints This subsection discusses how to check the satisability of constraints and how to maintain their normal forms. In the literature there are also simpler normal forms as a simple conjunction of equalities and disequalities (see [5, 13, 4] for papers devoted to this and related subjects). Disjunctions of disequality constraints can be handled by backtracking. We have used a more compact representation to simplify the search space. The most complicate part in the simplication of a constraint is the addition of an equality or a disequality. The unication algorithm can be used to detect if they are satisable and to help in this simplication. Another important point is the fact that our domains (types) for constraints have a nite number of constructors. We need to add a rule to detect inconsistencies like X 6= 0 ^ 8 Y (X 6= s(y )) for the nat type. To apply this rule we need some previous notions. Denition 4.5 Covering A set of terms t 1 ; : : : ; t n (none a variable) is complete for a variable X on a monomorphic type i for all the concrete elements s 2 H with type there exists i and a substitution such that s = t i. A covering for on X is the constraint built as the negation of a complete set of terms : : : ; t i (Y i ); : : : for X on : : : : ^ 8Y i X 6= t i ^ : : :

12 Example 4.3 X 6= 0 ^ 8 Y (X 6= s(y )) are coverings for nat on X. X 6= 0 ^ X 6= s(0) ^ 8 Y (X 6= s(s(y ))) A covering is unsatisable on H, what means that every constraint with a covering can be reduced to f alse. Now, we dene the rules to combine a constraint in normal form with a new constraint. In the following the substitution denotes the positive part of the constraint, i.e. = fx 1 =t 1 ; : : : ; X n =t n g. Addition of an equation t = s ^ V(X i = t i ) ^ c ` false if c has only disequalities, t; s are not uniable t = s ^ ^(X i = t i ) ^ c ` ^(X i = t i ) ^ ^(X 0 j = t0 j ) ^ c0 if c has only disequalities, = m:g:u:(t; s) = fx 0 1 = t0 1 ; : : : ; X m 0 = t0 mg, c ` c 0 Addition of a disequation 8 Zt 6= s ^ ^(X i = t i ) ^ c ` ^(X i = t i ) ^ c if c has only disequalities and t; s are not uniable 8 Z t 6= s ^ ^(X i = t i ) ^ c ` ^(X i = t i ) ^ _(X 0 j 6= t 0 j ) ^ c0 if c has only disequalities, and = m:g:u:(t; s) = f::; X 0 i = t0 i ; ::g 8 Z t 6= s ^ ^(X i = t i ) ^ c ` false if c has only disequalities and = m:g:u:(t; s) only binds variables in Z Note: The universal quantication on Z should be empty. Simplication rules true ^ c ` c false ^ c ` false c 1 : : : ^ c n ` false if it contains a covering c ^ c 1 :: ^ c n ` c ^ c 0 1 ^ :: ^ c 0 n if c contains the equalities and c i 's the disequalities of the whole constraint c ^ c i ` c 0 i, for each i c ^ c 1 _ :: _ c n ` c ^ c 0 1 ^ :: ^ c 0 n if c has equalities and the c i 's are single disequalities c ^ c i ` c 0 i, for each i Example 4.4 In previous examples we have computed the complements of a frontier of the expression true [] subs(s(0); X). Now, rule 5. can be applied to obtain: (true [] subs(s(0); X)) =) Rule 7 X 6= 0 [] true; X = s(x 0 ) [] (true [] subs(0; X 0 )) =) Rules for ; ` X = s(x 0 ) [] (true [] subs(0; X 0 )) The only frontier for (true [] subs(0; X 0 )) is fx 0 = 0 [] + 0g, which has an unique useful complement X 0 6= 0. X = s(x 0 ) [] (true [] subs(0; X 0 )) =) Rule 6 X = s(x 0 ) ^ X 0 6= 0 [] true Now, the narrowing sequence can be completed as follows: : : : =) Rule 5 X = s(x 0 ) ^ X 0 6= 0 [] invert(subs(s(x 0 ); s(0))) =)?X 0

13 4.4 Soundness and Completeness Finally, we can establish the soundness and completeness of our narrowing semantics. Due to the lack of space we will omit the proofs. Theorem 4.1 Soundness Let be a program. Any narrowing sequence c [] e sound outcome in the sense that =) c 0 [] e 0 computes a [c; c 0! e] I () w [c 0! e 0 ] I () for all environments : Notice that if e 0 is a term its valuation corresponds with the term itself (except the variables), giving the expected soundness result for succesful computations. The interpretation of a constraint c as an expression is obvious. Theorem 4.2 Completeness Let be a program, e an expression, c a constraint, s an element in H and a substitution that binds any variable of c; e into a ground term (ground substitution). If [(c! e) ] w s then there exists a narrowing sequence c [] e =) c 0 [] t, (with t a term), and a ground substitution such that t = s, and c ^ c ^ c 0 is satisable (where c ; c denote the constraints with positive part ; and no negative part). Proof Idea: The proof combines the ideas of the completeness of innermost narrowing, using the T operator, with the completeness proof of [17]. In fact the result is, in some sense, a corollary of this last one. 5 Related work The work uses some of the techniques developed for constructive negation [3, 4, 17]. However, they are adapted to a more general framework. Our more complex notion of constraint normal form forces us to redene the notion of complement used in Chan's papers. Chan's method to obtain constraint information from a frontier relies in the following property: :9Y ; Z(X = s ^ Q) $ 8Y (X 6= s) _ 9Y (X = s ^ :9Z)Q while Stuckey abstracts, into the CLP framework, to: :9Y ; c ^ Q $ (:9Y c) _ (:9Y c ^ Q) (see [17]). Our method uses a mixture of both of them, adding the rules for simplication of -expressions. These rules generalize the double negation simplication of Chan (which cannot be used in Stuckey's approach). The narrowing rule for default rules has an advantage with respect to Chan's work: The whole constraint is passed to the denitionless expression, what reduces the search space. This idea was pointed by Stuckey instead of the use only of the positive constraint (substitution) in Chan's paper. Only some few papers have been devoted to the combination of constructive negation with narrowing. [16] treats a dierent problem: to compute the answers to a disequation f(t) 6= s by computing the results for f(t) = s and then negating the resulting formula. The undened values for f(t) are not

14 taken into account (or f must be total). In our framework we can compute all the values for f(t), by bactracking, and then compare them with s. It is valid even if f(t) is undened, by adding a default rule default f(x) := r, with r 6= s. However, if f(t) has innitely many solutions the method is not eective, while negating a frontier of f(t) = s is. [6] denes a narrowing procedure to compute disunication (i.e. disequations over the Herbrand universe modulo an equational theory). It is complete when the equational theory is dened by a basic term rewriting system. The problem is also dierent from the treated in this paper. Another trend of work which makes use of innermost narrowing and negative information is present in the languages SLOG [7] and ALF [8]. Narrowing is combined with simplication using some rules by pure rewriting. In some cases, under the CWA, it is possible to dene a rewriting rule indicating when a function fails. This could optimize the computation and also can transform an innite computation (?) into a nite failure (f ail). The technique is independent of our work an can be used to optimize it. Another interesting approach to negation in PROLOG is the transformational one [1, 2]. New predicates are added in order to express the negative information. Informally, the complement of head terms of the positive clauses are computed and they are used later as the head of the negated predicate. However, in some cases, the new program contains some kind of universal quantication construct hard to be eciently implemented. In our case, this approach can be adapted when the program has no guards or guards without free variables. The default rule can be expressed as a normal rule. For instance, in the subs example, the new rule is: subs (0, Y) := Y 6= 0! { Y. However, in the presence of a constraint X 6= Y the program will produce innitely many solutions (if the type has a non constant constructor). 6 Conclusion In this paper we have studied the completion of partial functions with a default rule in functional logic languages. The narrowing rule has been modied to cope with these new rules. The used techniques are an extension of constructive negation: subderivations are used to detect when a function call will nitely fail by using the dening rules. Pure PROLOG can be interpreted as a subset of BABEL when predicates are implemented as boolean functions. By using default rules, PROLOG programs with negation are subsumed by Def-BABEL. The negated part of a predicate is obtained by using a default rule with body false. Furthermore, in our language, the programmer can freely use explicit negation and negation as failure. Kowalski pointed out the advantages of this distinction for knowledge representation. The paper has focused on the extension of narrowing based languages using a constructor discipline. This restricts our constraint system to the

15 Herbrand Universe. However, we agree [17] that it is more general (and natural) to study the problem in a CLP framework. Although there are few paper addressing the integration of functions, predicates and constraints, we believe that default rules can be best described in the context of Constraint Functional Logic Programming [12]. As a future work, we plan to incorporate these techniques to lazy narrowing. The coroutining implementation technique reported in [3, 4] can be seen as an application of lazy evaluation. Acknowledgements This research was supported in part by the spanish project TIC/ C References [1] R. Barbuti, D. Mancarella, D. Pedreschi, F. Turini. Intensional Negation of Logic Programs. Proc. TAPSOFT'87, Springer LNCS 250, , [2] R. Barbuti, D. Mancarella, D. Pedreschi, F. Turini. A Transformational Approach to Negation in Logic Programming. Journal of Logic Programming, 8(3): , [3] D. Chan. Constructive Negation Based on the Complete Database Proc. Int. Conference on Logic Programming'89, The MIT Press, , [4] D. Chan. An Extension of Constructive Negation and its Application in Coroutining. Proc. NACLP'89, The MIT Press, [5] H. Comon, P. Lescanne. Equational Problems and Disunication. Journal of Symbolic Computation, 7: , [6] M. Fernandez. Narrowing Based Procedures for Equational Disunication. Applicable Algebras in Eng. Communications and Computing, 3:1-26, [7] L. Fribourg. SLOG: A Logic Programming Language Interpreter based on Clausal Superposition and Rewriting. Proc. Symp. on Logic Programming, IEEE Comp. Soc. Press, [8] M. Hanus. Compiling Logic Programs with Equality. Proc. PLILP'90, Springer LNCS, [9] J. Jaar, J.L. Lassez. Constraint Logic Programming. Proc. 14th ACM Symp. on Princ. of Prog. Lang., , [10] H. Kuchen, F. Lopez-Fraguas, J.J. Moreno-Navarro, M. Rodrguez-Artalejo. Implementing a Lazy Functional Logic Language with Disequality Constraints. Joint International Conference and Symposium on Logic Programming, The MIT Press, , [11] K. Kunen. Negation in Logic Programming. Journal of Logic Programming 4: , [12] F.J. Lopez-Fraguas. A General Scheme for Constraint Functional Logic Programming. Proc. ALP'92, Springer LNCS, [13] M. Maher. Complete Axiomatization of the Algebras of Finite, Rational and Innite Trees. Proc. 3rd Symp. on Logic in Computer Science, , [14] R. Milner, M. Tofte, R. Harper. The Denition of Standard ML. The MIT Press, [15] J.J. Moreno Navarro, M. Rodrguez Artalejo. Logic Programming with Functions and Predicates: The Language BABEL. Journal of Logic Programming 12: , 1992.

16 [16] M.J. Ramrez, M. Falaschi. Conditional Narrowing with Constructive Negation. Proc. 3rd Int'l Workshop on Extension of Logic Programming ELP'92, Springer LNCS 660, 59-79, [17] P. Stuckey. Constructive Negation for Constraint Logic Programming Proc. IEEE Symp. on Logic in Computer Science, IEEE Comp. Soc. Press, 1991.