Extending RDBMS for allowing Fuzzy uantified ueries Leonid José Tineo Rodríguez Departamento de Computación, Universidad Simón Bolívar Apartado 89000, Caracas 1080-A, Venezuela Phone: +58 2 9063269, Fax: +58 2 9063243 email:leonid@ldc.usb.ve Abstract. This paper is mainly concerned with the extension of database management systems querying capabilities, so that users may address queries involving preferences and get discriminated answers. The use of flexible predicates and linguistic quantifiers interpreted in the framework of the fuzzy set theory is advocated for defining a query language, called SLf. This language extends the functionalities offered by SL and it is considered here from a query processing point of view. We concentrate this work in the fuzzy quantified SLf queries semantic and evaluation mechanism. Keywords: SLf, Fuzzy ueries, Fuzzy uantifiers, RDBMS extension, uery Evaluation. 1 Introduction It is often said that commercial DBMS suffer from a lack of flexibility (in many respects)[8,2], and despite the tremendous evolution of this research area in the last decade, imprecision has not been taken into account. In fact, a twofold hypothesis has been maintained nearly all the way long: data are assumed to be precisely known and queries are intended to retrieve elements that qualify for a given boolean condition. This paper concentrates on the second aspect of this hypothesis. In the context of regular relational databases (where data are precisely known), the objective is to provide users with new querying capabilities based on conditions which involve preferences and describe more or less acceptable items, thus defining flexible queries. Since the problem is no longer to decide whether an element satisfies (or not) a condition but rather the extent to which it satisfies this condition, one of' the advantages lies in the "natural" ordering of the answers (discrimination) which allows for calibration if desired. In the remainder of this paper, ordinary relational DBMS are considered. This means that data stored are not pervaded with imprecision and/or uncertainty and are assumed to be precisely known. In this context, several approaches for the expression of preferences inside user queries have been proposed in the literature. It has been shown in [1] that the solution founded on fuzzy sets for interpreting preferences is the most general one. A query language, called SLf, supporting fuzzy queries in the context of a relational data model has thus been proposed [2]. This query language is an extension of SL, which is a standard for database querying. There exist other extensions of SL proposed to flexible database querying[10,13,15], but SLf is the most complete and the only one that allows the expression of fuzzy quantified queries[11,17]. We present here the semantic of such queries according to an interpretation of fuzzy quantifiers appropriate to database querying[3,7]. An important point concerns the evaluation of such queries. In conventional DBMS, the problem of query evaluation remains somewhat open since given a query, in general the optimal evaluation way cannot be reached. For fuzzy queries the process becomes more complex for two reasons: i) the available access paths can not be directly used, and ii) a larger number of tuples is selected by fuzzy conditions with respect to boolean ones. In this context, it appears useful to understand the connections which exist between properties tied to boolean conditions and fuzzy ones, so that fuzzy query processing can come down to Boolean query processing (at least partly). An evaluation method, called derivation, exploiting such properties is described in [1,4,6]. The applicability of this method to the evaluation to SLf fuzzy quantified queries is discussed in this paper, as well as the integration of a derivation-based SLf query interface on top of a regular relational DBMS. The paper is organized as follows. Section 2 introduces the concept of fuzzy quantifiers and their classification. Section 3 presents the fuzzy quantifiers interpretarion for database querying. Section 4 is dedicated to a presentation of the fuzzy quantified statements in SLf. Section 5 is devoted to the use of the derivation method allowing for processing fuzzy quantified SLf queries. In section 6, we show how a query evaluation component based on this method can be added on top of a regular relational DBMS so that this system can deal with SLf queries. The conclusion summarizes the principal contributions of the paper and some future works are pointed out.
2 Fuzzy uantifiers uantifiers can be used to represent the amount of items satisfying a given predicate. Classic logic allows for the use of only two quantifiers, the universal, (for all), and existential, (exists), quantifiers. In an attempt to provide a more flexible knowledge representation tool, Zadeh[22] introduced the concept of linguistic quantifiers. In addition to two classic quantifiers, linguistic quantifiers are exemplified by terms such as "most", "a few", "about 5", "at least half". These linguistic quantifiers are represented as fuzzy sets. That s why they are called Fuzzy uantifiers. Two types of fuzzy quantifiers are distinguished: absolute and proportional. Absolute quantifiers represent amounts that are absolute in nature such as "about 5" or "more than 20". An absolute quantifier can be represented by a fuzzy subset, such that for any nonnegative real p R+ the membership grade of p in (denoted by (p)) indicates the degree to which the amount p is compatible with the quantifier represented by. Proportional quantifiers. such as "at least half" or "most", can be represented by fuzzy subsets of the unit interval, [0,1]. For any prportion p [0,1], (p) indicates the degree to which the proportion p is compatible with the meaning of the quantifier it is representing. Yager [21] has investigated a number of issues related to linguistic quantifiers. In [19,20] he provides a survey of some of their applications. Dubois and Prade(10) have also contributed to the development of these objects. Functionally, linguistic quantifiers are usually of one of three types, increasing, decreasing, and unimodal. Increasing quantifiers (as "at least n", "all", "most") are characterized by: a b for all a<b ( ) ( ) Decreasing quantifiers (as "a few", "at most n") are characterized by: a b for all a<b ( ) ( ) Unimodal quantifiers (as "about q") have the property that: For some c ( c) = 1 a b and ( ) ( ) for all a<b c and ( a) ( b) if c a<b 3 Fuzzy uantifiers Interpretation The interpretation of fuzzy quantifiers has received attention from several researchers [9,14,21,23,16]. In spite of the existence of several interpretations for fuzzy quantifiers, there is not one totally appropriate for database querying [11] and that can be evaluated in an efficient way[5,6]. It would be of supreme interest for the problem of Database Flexible uerying to get such an interpretation. We present an interpretation of fuzzy quantifiers that is a natural extension of quantifiers of classical logic. Our interpretation is based in a linguistic transformation principle. We make a translation of fuzzy quantified statements into statements using existential quantifier, conjunction and negation. Thereafter we will use the most common fuzzy interpretation of these operators for taking the linguistic quantifiers interpretation[17]. We are especially interested in quantified statements of the form X s ARE A (for short (X,A)), where is a quantifier represented as a fuzzy set, X is a regular set and A is a fuzzy predicate. Our special interest is due to the kind of fuzzy quantified queries to be studied in this work. However, we have also propose the interpretation for statements of the form B X s ARE A where B is a fuzzy predicate. We do not deal here with these statements because they are applicable to other kind of quantified queries that will be matter of future works. If is a increasing absolute quantifier, the satisfaction degree of the sentence (X,A) is: ( ( ) = ( ) i X, A min i sup ( x) i { 0.. X } sup, ( ) If is an increasing proportional quantifier, we have the satisfaction degree: sup, ( ( X A ) = i, min i X sup i { 0.. X } A ( ) ( ( x) ) If is a decreasing absolute quantifier, the satisfaction degree of the sentence (X,A) is: ( ( ) = ( ) i+ ( ( )) X A sup i 1 ( 3 ), min, x inf 1 A i { 0.. X } If is a decreasing proportional quantifier, we have the satisfaction degree: ( ( ) ( ) ( 4 ) X, A = sup min + i, i 1 inf ( 1 ( x)) X A i { 0 X } A ( 1 ) ( 2 )
If is an unimodal absolute quantifier, the satisfaction degree of the sentence (X,A) is: ( ) l ( ( )) sup min l, x sup, A l { 0.. X } ( ( )) X, A = min ( r) r+ 1 ( ( x) ) sup min, inf 1 A r { 0.. X } If is an unimodal proportional quantifier, we have the satisfaction degree: l ( ) l ( ( )) sup min { }, x X sup, A l 0 X ( ( ) X, A = min r ( ) r+ ( ( )) sup min, 1 x { } X inf 1 A r 0 X ( 5 ) ( 6 ) An evaluation method for fuzzy queries in SLf, called derivation, is described in [1,4,6]. This method exploits the existing connections between properties tied to regular conditions and fuzzy ones. Thus, the fuzzy query processing can come down to Boolean query processing (at least partly). The applicability of this method to simple queries and nesting in SLf (without fuzzy quantifiers) was discussed in [6]. However, it seems to be inapplicable to quantified statements with the previously known interpretations [6,17]. We will show later that with our interpretation this technique becomes applicable. That s the major contribution of this work. Regarding with previous interpretation for fuzzy quantified statements, our interpretation is comparable to that of Prade[14]. Our interpretation for sentences of the form X s ARE A is equivalent to the Possibility measure given by Prade s one for increasing quantifiers. And in case of decreasing quantifiers, our interpretation for sentences of the form X s ARE A is equivalent to the Prade s Necessity measure. Prade does not give an interpretation for unimodal quantifiers. There is also a similarity between our interpretation and that of Ralescu[16] for sentences of the form X s ARE A. But Ralescu gives an integer number for the cardinality and we give a fuzzy integer. 4 Fuzzy uantified ueries in SLf SL has been defined in the 70's in order to query relational databases in a non-procedural way, by means of simple and powerful constructs. This language has been extended in a straightforward manner to allow for flexible queries in which fuzzy predicates express preferences. This gave birth to the language called SLf [2], which has the same general philosophy as SL (as to querying features and syntax in particular) and offers new possibilities regarding flexible querying. In this section, we present the syntax of single-block partitioned queries with fuzzy quantifier, which constitute the kind of queries that we will consider in the following from an evaluation point of view. SLf has a construct for single-block partitioned queries with fuzzy quantifier, which has the following structure: SELECT <t> <A> FROM <R> GROUP BY <A> HAVING <> <fc>. where <t> is a threshold associated with the query (is optional), <A> is an attribute (or attribute list) of relations in <R>, <> is any fuzzy quantifier, <fc> represent a fuzzy condition. The semantics of this query is: The query returns the fuzzy relation Rf on {a / ( x R / x.a=a) and (((Xa,fc)) <t>) } with Rf (a)= ((Xa,fc)) Where Xa = {x R / x.a=a} Example 1 Let us consider the relation EMP(#emp, e-name, salary, job, age, #dep) describing employees where the attributes have their canonical meanings and its extension: #emp e-name Salary Job Age #dep 10 Martin 2000 K1 40 1 22 Calvin 1000 K4 38 1 78 Luther 1500 K2 50 1 41 Johnson 1200 K3 40 2
35 Smith 1000 K3 39 2 90 Peters 1200 K2 41 2 56 Anderson 1500 K2 40 3 82 Dobson 1000 K4 36 3 64 Mc Dowell 2000 K1 50 3 The query "Find the departments where most of the employees are about 40 years", with a threshold 0.5, may be expressed by: SELECT 0.5 #dep FROM Emp GROUP BY #dep HAVING MOST_OF age = About40. with "MOST_OF" a proportional quantifier whose characteristic function 1 0 0 1/6 1/3 1/2 2/3 5/6 1 About40 a fuzzy predicate with the characteristic function: The calculation of the result is shown in this table: #dep i i fc x (a) i #emp Age ( ) 1 0 0 35 40 45 a ( ) i = sup i ( ) = (, ) Xa ( ) min i i ( Xa, fc) 1 2 3 1 10 40 1 0 0 2 22 38.6.5.5 3 78 50 0 1 0 1 41 40 1 0 0 2 35 39.8.5.5 3 90 41.8 1.8 1 56 40 1 0 0 2 82 36.2.5.2 3 64 50 0 1 0 Finally, this query delivers the fuzzy relation #dep Membership degree 1.5 2.8.5.8.2 5 Derivation Principle for SLf uantified ueries Beyond the language definition, an important issue concerns the processing of fuzzy queries. The strategy presented hereafter assumes that a threshold t is associated with a SLf query in order to retrieve only those tuples that satisfy the condition with a degree greater or equal to t. The idea advocated here [6] (which is not the only possible one) is to use an existing database management system that will process regular Boolean queries. An SL query is derived from the SLf expression in order to retrieve the t-cut. That is to say, the reagular set of tuples that satisfy the condition with a degree greater or equal to t. Then, the fuzzy query can be processed on this set thus avoiding the exhaustive scan of the whole database. Remark that the derived SL query is not equivlengt to the original SLf. The SL query delivers a regular set, while the result of the SLf query is a fuzzy set. The principle is to express the t-cut in terms of a query involving only regular operators and expressions. If the condition involves means operators as connectors, the derived boolean condition produces a superset of the t- cut. The efficiency of the transformation in simple queries has been studied in [4]. When the derivation produces a superset of the t-cut it is said that it is weak, when it produces exactly the t-cut is said that it is strong. The application of this principle to simple and compound predicates (without quantifiers) has been object of previous works [3,6]. Here we concentrate on the application of this principle to quantified queries.
Definition 1 Let s SELECT <t> <A> FROM <R> GROUP BY <A> HAVING fc be a fuzzy quantified query in SLf. The derived SL query for this query is: SELECT <A> FROM <R> WHERE DNWC( fc,,t) GROUP BY A HAVING DNHC( fc,,t). where DNWC( fc,,t) denotes the derived necessary condition for the WHERE clause and DNHC( fc,,t) denotes the derived necessary condition for the HAVING clause obtained from the initial condition " fc" in the HAVING clause. 5.1 Derivation of a quantified query We demonstrate the applicability of the derivation principle here for the case of increasing absolute quantifiers. Proposition 1 Let s be an increasing absolute fuzzy quantifier, fc a fuzzy condition SELECT <t> <A> FROM <R> GROUP BY <A> HAVING fc a fuzzy quantified query. Then DNWC( fc,,t) = DNC(fc,,t) DNHC( fc,,t) = (count(*) n) Where n is the lowest natural number such that (n) t Proof Let's Xa be the set of the partition of <R> group by <A> for the value a of <A> That is: Xa = {x in R / x.a=a} ((Xa,fc)) <t> sup ({min( (i),i-sup { fc (x)/x in Xa}) / i in 0.. Xa }) <t> Let's n be the lowest natural number such that (n) t then, as is increasing: for all i in 0..n-1 min( (i),i-sup { fc (x)/x in Xa}) < <t> and for all i in n.. Xa min( (i),i-sup { (x)/x in Xa}) <t> i-sup { fc (x)/x in Xa} <t> Now we have: ((Xa,fc)) <t> sup ({min( (i),i-sup { fc (x)/x in Xa}) / i in n.. Xa }) <t> {x in Xa / fc (x) <t>} n {x in R / fc (x) <t> and x.a=a} n Thus we have: DNWC( fc,,t) = DNC(fc,,t) DNHC( fc,,t) = (count(*) n) Example 2 If we want to find "The departments where at least about 10 employees are about 40 years", with a threshold 0.5, we write the SLf statement: SELECT 0.5 #dep FROM Emp GROUP BY #dep HAVING AtLeastAbout10 (age~40). with About40 as in Example 1 and "AtLeastAbout10" a fuzzy quantifier whose characteristic function is 1 0 0 7 10 An age a satisfy About40 with a threshold 0.5 iff 37.5 a 42.5 The lowest n such that AtLeastAbout10(n) 0.5 is n=9
So DNWC(AtLeastAbout10 (age=about40),,0.5) = DNC(age=About40,,0.5) = 37.5 age AND age 42.5 DNHC(AtLeastAbout10 (age=about40),,0.5) = count(*) 9 The derived SL query is: SELECT #dep FROM Emp WHERE 37.5<=age AND age<=42.5 GROUP BY #dep HAVING count(*) 9. 5.2 Summary of the derivation for diverse quantifiers Proposition 2 Let s be a fuzzy quantifier, fc a fuzzy condition SELECT <t> <A> FROM <R> R 1 GROUP BY <A> HAVING fc a fuzzy quantified query (R 1 is an alias for R). If is Absolute Let s l be the minimum value such that (l) t, r be the maximum value such that (r) t If is Increasing then: DNWC( fc,,t) = DNC(fc,,t) DNHC( fc,,t) = (count(*) l) If is Decreasing then: DNWC( fc,,t) = DNC(fc,,1-t) DNHC( fc,,t) = (count(*)+r SELECT count * FROM R WHERE A=R 1.A) If is Unimodal then: DNWC( fc,,t) = TRUE DNHC( fc,,t) = (l SELECT count * FROM R WHERE A=R 1.A AND DNC(fc,,t)) AND (r SELECT count * FROM R WHERE A=R 1.A AND DSC(fc,>,1-t)) If is Proportional Let s q l be the minimum value such that (q l ) t, q r be the maximum value such that (q r ) t If is Increasing then: DNWC( fc,,t) = DNC(fc,,t) DNHC( fc,,t) = (count(*)/q l ) SELECT count * FROM R WHERE A=R 1.A If is Decreasing then: DNWC( fc,,t) = DNC(fc,,1-t) DNWC( fc,,t) = ((count(*)/(1-q r )) SELECT count * FROM R WHERE A=R 1.A) If is Unimodal then: DNWC( fc,,t) = TRUE DNHC( fc,,t) = (count(*)*q l SELECT count * FROM R WHERE A=R 1.A AND DNC(fc,,t)) AND (count(*)*q r SELECT count * FROM R WHERE A=R 1.A AND DSC(fc,>,t)) The demonstration of this proposition for the application of the derivation principle to all type of fuzzy quantifiers is similar to the prove of proposition 1. We don't present it here for space reasons, see [17] for details. 6 Evaluation of Fuzzy uantified ueries on top of a RDBMS We present here an evaluation mechanism based in the derivation principle. It is then possible to use an existing relational DBMS to process the derived query. In so doing, one can expect to take advantage of the implementation mechanisms handled by the DBMS to reach acceptable performances. 6.1 Architecture The presented architecture is strongly connected with the derivation method since it implies a query transformation step. In fact, the problem is a bit more complex since the derived query provides a usual (crisp) relation whereas we want to obtain a fuzzy relation, i.e., a relation containing weighted tuples. The computation of the final membership degrees can be performed by the DBMS during the processing of the derived SL query if the system allows for the inclusion of external functions in the query. If this is not the case, the degrees
must be computed by means of an external procedural program. We will make this assumption in the following, for the sake of generality. Fuzzy query processing reduces mainly to a transformation procedure located on top of an existing DBMS according to the architecture proposed, which should keep the development effort limited. Answer UERY INTERFACE SLf Fuzzy terms definitions SLf results SL query SLf query TRANSLATION MECHANISM SL EVALUATION PROGRAM Fuzzy terms definitions SL Result Fuzzy terms definitions FUZZY TERMS CATALOG Catalog storing REGULAR DATABASE MANAGEMENT SYSTEM Figure 1: Architecture for implementing SLf The translation mechanism generates derived SL statements that are processed by a procedural evaluation program written in a host language, and it also determines the expressions allowing for the computation of the degrees. The program obtained processes the SL queries, computes the membership degrees and calibrates the answer if necessary. 6.2 Algorithm for ueries Evaluation To obtain the tuples of the solution of the fuzzy query just executing the derived query is needed. However, if one want to compute the membership of each element, on must execute an algorithm that processes the result of the derived query. Hereafter, we give the external program, written in a host language that must be used to evaluate a query with an increasing absolute fuzzy quantifier. This program makes the calibration of result in order to avoid extra items in case of weak derivation. The derived query is lightly modified for allowing compute the degrees. Program 1 declare c cursor for SELECT * FROM R WHERE DNC(fc,>=,t) GROUP BY A HAVING count(*)>=n. result:=empty; open c; fetch c into x; while code(c)<> Active Set Empty do begin A:=x.A; sup[0]:= 1; (* At Least None <=> True *) sup[1]:= 0; (* End mark for decreasing list*) while code(c)<>activesetempty and x.a=a do (* Grouping *) begin := f c (x); (* satisfaction degree of fc(x) *) if (>=t) then (* calibration *) DecInsert(,sup); (* sup :fc(x)degrees decreasing list*) fetch c into x; end; Sup := 0; i := n; while (sup[i]<>0) do (* Cuantif.Stat. degree computation *) begin := min ( (i),sup[i]); if >Sup then Sup: =;
i:=i+1; end; if (Sup>=t) then (* calibration *) result:=result+{sup/a} (* A is in result with degree Sup *) end; close c; Obviously, the calibration tests can be omitted in case of an strong derivation. We have developed the algorithms for evaluating queries with all kind of quantifiers via the derivation principle. They are very similar to the previous one. We do not present them here by space restriction, see [17] for details. The previous program delivers the SLf result without order. The sorting is not made up due to the semantic of SLf which states that the result of a query is a fuzzy set. However one should want to see the result in satisfaction degree decreasing order of tuples. It can be performed changing in the propram the set variable result by a list and making oredered insertions, or viewing the result with and ordering filter. 6.3 About the Efficiency of the Derivation Principle The derivation principle for quantifiers is strong, we have shown that via equivalences. Only when the derivation of the condition fc under the quantifier is weak, the derived query delivers extra tuples (tuples that ar not in the t-cut of the SLf query solution). The derivation of a fuzzy condition fc is weak only if fc contains means operators. The proportion of additional tuples in this case (which may be seen as an index of efficiency) is examined in [4]. The use of the derivation principle for the evaluation of the query in the example 1 would avoid the degrees calculation for the department 3 and for the employee 78 (4 tuples of 9). It also would avoid the computation membership degrees and minimum for portions 1/3 (2 of 5 calculations). We have developed a prototype of SLf based on the presented strategy and another with the naive strategy (without using the derivation). With these prototypes we are carrying out experimental tests of efficiency. The results of this tests will be presented in future works. We expect to confirm in practice those that we have sustained about the efficiency of the derivation principle. 7 Conclusion In this paper we have dealt with relational database management systems where conventional data (neither imprecise, nor uncertain) are stored, which support fuzzy quantified queries. The semantics and processing of such queries have been discussed. We have presented an interpretation of fuzzy quantifiers that is based in a simple linguistic transformation principle. It is easy to show that the given interpretation is completely suitable for database flexible querying, it satisfies all the postulates given by Lietard[11]. This feature is an advantage over most of the other interpretation that do not satisfy all of these postulates, only the Yager s OWA interpretation [19] satisfies also these constrains. It was not possible to apply the derivation principle to queries using quantifiers with the previous known interpretations. It has been shown that, with this interpretation, it is possible to derive boolean queries, which return a t-cut of the initial fuzzy query. Then, the fuzzy query can be processed on this set thus avoiding the exhaustive scan of the whole database. The major interest of this approach is to take advantage of the implementation techniques available in existing relational DBMS. Other extensions of RDBMS have been made to allow flexible querying, but none of them allows quantified queries. We are making experimentation with a prototype of SLf for showing he efficiency of the presented mechanism. In SLf is also possible to use the fuzzy quantifiers as nesting operators, we think that this kind of queries may also be evaluated via the derivation principle, but it is matter of future research. 8 References [1] P. Bosc, O. Pivert Some approaches for relational databases flexible querying, International Journal of Intelligent Systems, Vol 1, No. 3/4, pp. 323-354, Feb 1992. [2] P. Bosc, O. Pivert SLf: A Relational Database Language for Fuzzy uerying, IEEE Transactions on Fuzzy Systems, Vol 3, No. 1, Feb 1995. [3] P. Bosc, O. Pivert, K.Farquhar Integrating Fuzzy ueries into an Existing Database Management System: An Example, International Journal of Intelligent Systems, Vol 9, pp 475-492,1994 [4] P. Bosc, O. Pivert On the efficiency of the alpha-cut distribution method to evaluate simple fuzzy relational queries, Advances in Fuzzy Systems-Applications and Theory, Vol 4, Fuzzy Logic and Soft Computing,
B. Bouchon-Meunier, R.R.Yager,L.A. Zadeh eds, Wold Scientific, pp 251-260, 1995. [5] P. Bosc, L. Liétard, O. Pivert, uantified statements and Database Fuzzy querying, Fuzziness in Database Management Systems, P. Bosc & J. Kacprzyk Eds, Physica Verlag, pp. 275-308,1995. [6] P. Bosc, O. Pivert, "SLf query functionality on top of a regular relational DBMS", in: Knowledge Management in Fuzzy Databases, O. Pons, M.A. Vila, and J. Kacprzyk (Eds.), Heidelberg: Physica-Verlag, to appear. [7] Buckles, J.Buckley & F.Petry Architecture of FAME: Fuzzy Address Mapping Environment, Proceedings of 3rd IEEE International Conference on Fuzzy Systems, pp 308-312, 1994. [8] E. Cox Relational Database ueries using Fuzzy Logic, Artificial Intelligent Expert, pp 23-29, Jan 1995. [9] Dubois, H. Prade Fuzzy cardinality and the modeling of imp recise quantification, Fuzzy Sets and Systems, Vol. 16, No. 2, pp 199-230, 1985. [10]J.Kacpryzyk & S.Zadrozny, Fuzzy ueries in Microsoft AccessTM v.2, Proceedings of Fuzzy IEEE 95 Workshop on Fuzzy Database Systems and Information Retrieval, pp 61-66, 1995. [11]L. Lietard Contribution `a Línterrogation Flexible de Bases de Données: étude des propositions quantifiées floues These de Docteur de Lúniversité de Rennes [12]W. Mansfield & R.Fleischman. A High-performance, Ad-hoc, Fuzzy uery Processing System Journal of Intelligent Systems, Vol. 2, pp. 397-420, 1993. [13]H.Nakajima, T.Sogoh, M.Arao Fuzzy Database Language and Library-Fuzzy Extension to SL, Proceedings of Second IEEE International Conference on Fuzzy Systems, pp 477-482, 1983. [14]H. Prade, A tow-layer fuzzy pattern matching procedure for the evaluation of conditions involving vague quantifiers, Journal of Intelligent and Robotics Systems, No. 3, pp 93-101, 1990. [15]F. E. Petry Fuzzy Databases Principles and Applications International Series in Intelligent Technologies, Klumer Academic Publishers. [16]D. Ralescu "Cardinality, quantifiers, and the aggregation of fuzzy criteria" Fuzzy Sets and Systems 69, pp 355-365. 1995 [17]L. Tineo, Interrogaciones Flexibles en Bases de Datos Relacionales, Universidad Simón Bolívar, Technical Report, Jan 1998. [18]R.R. Yager, General multiple-objetive decision functions and linguistically quantified statements, International Journal of Man-Machine Studies, No. 21, pp 389-400, 1984. [19]R.R. Yager, Reasoning with fuzzy quantified statements: Part I, Kybernetes, 14, 233-240 (1985). [20]R.R. Yager, Reasoning with fuzzy quantified statements: Part II, Kybernetes, 15, 111-120 (1986). [21]R.R. Yager, "Connectives and quantifiers in fuzzay sets" Fuzzy Sets System. 40, 39-76 (1991). [22]L.A. Zadeh, "A thepry of approximate reasoning" in Machine Intelligence, Vol. 9, J. Hayes, D. Michie, and L. I. Mikulich, Eds., Halstead Press, New York, 1979, pp. 149-194. [23]L.A. Zadeh, A computational approch to fuzzy quantifiers in natural languages, Computer Mathematics with Applications, No. 9, pp 149-183, 1983.