Using Ripple Down Rulesbased Systems for Acquiring Fuzzy Domain Knowledge
Rodrigo MartínezBéjar^{1}, Hossein Shiraz^{2} and Paul Compton^{2}
1 Spanish Scientific Research Council, Avda. La Fama, 1, C. P. 30080 Murcia, Spain. Email: rodrigo@pandora.dif.um.es
^{2 Department of Artificial Intelligence, School of Computer Science and Engineering, The University of New South Wales, Sydney, 2052 NSW, Australia. Email : {hossein,compton}@cse.unsw.edu.au }Abstract
Fuzzy rulebased systems allow a more natural expression of concepts by experts and users than crisp systems. Although the use of fuzzy concepts partially reduces the maintenance problems it introduces other problems in tuning the numbers used by the system. On the other hand Ripple Down Rules provide easy maintenance but only for crisp concepts, albeit that the crisp concepts can be refined in local contexts. The aim of this paper was to develop a theoretical foundation for combining RDR and fuzzy rules to try to capture the advantages of both. We believe that advantages can be demonstrated, but a number of issues remain to be resolved.
Ripple down rules (RDR) is a knowledge acquisition technique developed from the maintenance experience with an expert system (Compton et al., 1989). The main motivation for developing RDR was the fact that experts could not explain how they had reached conclusions. Nevertheless, they were capable to justify the correction of the conclusions by attending to the context in which they had been provided (Compton and Jansen, 1990). RDR uniquely uses the knowledge provided by experts in the context it was provided, that is, by following the sequence of evaluated rules. Moreover, if the expert does not agree with a conclusion, knowledge in the form of a new rule can be added. In this sense, rules are never removed or corrected, only added.
Two main RDRbased approaches have been developed recently. Multiple Classification Ripple Down Rules (MCRDR) (Kang, 1996) is an extension of the basic aspects of RDR for providing multiple independent conclusions. With MCRDR, more general than those of single classification can, hence, be performed. When experts are maintaining a MCRDR system, they must construct a rule containing the differences between the case is entered to the system and the case associated to the last true rule in the KB. This process will be repeated until there is no case (associated to any rule) satisfying the rule.
A further RDRbased approach developed recently is the socalled Ripple down ruleOriented Conceptual Hierarchy (ROCH) (MartínezBéjar et al., 1997b). The basic idea concerning ROCHbased systems is that experts themselves can construct and validate domain knowledge while they enter knowledge to the KB. The purpose of this paper is to obtain a formal model to extend the knowledge acquisition/representation schema underlying current ROCHbased systems so that fuzzy domain knowledge can be acquired/represented. The aim is achieved by exploiting the characteristics of fuzzy domains in combination with the RDR philosophy. Thus, by introducing some assumptions, a model for acquiring knowledge in fuzzy contexts through RDR has been constructed. The ideas in this article will generally be illustrated with an existing KBS project for environmental planning in Spain.
The structure of the paper is as follows. Section 2 offers a description of the work done in RDR todate. In Section 3, we offer a brief introduction to the concept of fuzzy logic and fuzzy expert systems. Also, a formal manner for modelling fuzzy modifiers as well as fuzzy frequency quantifiers is proposed. Section 4 provides a knowledge representation schema that allows to adapt ROCHbased systems to fuzzy domains. Section 5 shows how cases are constructed in our approach. In Section 6, we analyse the different situations that can arise when a case is run in the model presented. Section 7 proposes a mechanism partially based on some fuzzy logic properties to acquire/show conclusions. In Section 8, the process required to acquire rule conditions in the system is described. Finally, in Section 9 we present conclusions.
Ripple down rules (RDR) is a knowledge acquisition technique and expert system methodology that was developed as a result of maintaining a medical expert system, the GARVANES1 (Compton et al., 1989). From a long maintenance experience with this system, it became clear that when experts were asked how they had reached a particular conclusion they did not and could not explain how they had reached their conclusion. Rather, they justified that the conclusion was correct, this justification being a function of the context in which it was provided (Compton and Jansen, 1990; Compton, 1992). The justification varied depending on whether the expert was trying to justify their conclusion to a fellow expert, a trainee, lay person or knowledge engineer, etc. This viewpoint on knowledge has much in common with situated cognition critiques of Artificial Intelligence and expert systems (Dreyfus and Dreyfus, 1988). These critiques do not necessarily lead to abandoning the expert system endeavour, but change the focus of development (Winograd and Flores, 1987; Clancey, 1991; Clancey, 1993). RDR is a practical realisation of, at least, part of these viewpoints.
The RDR approach produces a structure IF...ELSIF....ELSIF....ELSIF..., etc., that is, a decision list but with decisions refined by further decision lists (Catlett, 1992). Such a structure is also a decision tree, although it is normally very unbalanced, so that is better described in a decision list. The aim of RDR is to use the knowledge an expert provides only in the context within which it is provided. For rule based systems, it was assumed that the context was the sequence of rules which had been evaluated to give a certain conclusion. Thus, if the expert disagrees with this conclusion and wishes to change the knowledge base so that a different conclusion is reached, knowledge is added in the form of a new rule of whatever generality the expert requires. Moreover, this rule can only be evaluated after the same rules are evaluated with the same outcomes as before. With this approach, rules are never removed or corrected, only added. All rules provide a conclusion, but the final output of the system comes from the last rule that was satisfied by the data.
An essential part of any RDR system is the maintenance of cornerstone cases. These cases are cases that caused some change to the system. That is, they are cases, which caused the expert to create a new rule. For each rule in a system there is a cornerstone case. There are several reasons why these are important. Trivially they provide a history of the development of the system for documentation purposes. More importantly, they provide a context within which new rules can be created.
The initial RDR systems built are only single classification systems, where rules are linked in a binary tree structure and a single case is stored with each rule. To correct a conclusion, a new rule is appended at the end of the inference path through the tree that had produced the wrong conclusion. More formally, Scheffer (1996) has defined a single classification RDR by means of exception (true) rules and "ifnot" (false) rules. By using this approach, the exception rules are evaluated once a rule is satisfied. If so, none of the ifnot rules are tested. Single classification RDR has shown to be a successful approach in the development of the PEIRS system, which is a medical expert system used for pathology laboratory report interpretation. This system was built, whilst in routine use, by experts with no help of knowledge engineers (Edwards et al., 1993).
The basic philosophical background of RDR has been extended to provide multiple independent conclusions (MCRDR) (Kang and Compton, 1992). The same events occur in a MCRDRbased system as in a simple RDRbased one, but with the added requirement that rules may have multiple cornerstone cases, and these are associated with multiple conclusions (Kang et al., 1995; Kang, 1996). More formally, MCRDR can be defined as an narray tree structure containing exception rules and siblings so that all of these, which are situated at the first level, are evaluated. Then, the list of children is also evaluated until all children from true parents have been examined. Thus, the conclusion for the case under question is formed by the last true rule of each pathway.
When experts maintain a MCRDR system, they work as follows. First, they are required to construct a rule containing the differences among one of the (existent) cornerstone cases and the input case. In order to exclude a further case when other stored cornerstone cases satisfy the rule, further conditions will be required to be added. This process will take place repeatedly until there is no stored cornerstone case satisfying the rule. This could lead to maintenance processes involving many cases to be checked for each new rule. However, Kang et al. (1995) have shown that after seeing a few cases (normally two or three), experts supply an adequate rule in terms of precision fundamentally. With all, Kang (1996) has demonstrated experimentally that knowledge bases produced by MCRDR systems are usually more compact and with less repetition than RDR. This author has indicated that such a phenomenon can be due to the fact that MCRDR systems focus more on exploiting experience rather than depending on the KBS structure.
More recently we have designed and implemented a framework, which has been termed Ripple down ruleOriented Conceptual Hierarchy (ROCH)based system (MartínezBéjar et al., 1997b), that allows experts to construct and validate domain knowledge ontology while they enter knowledge to the KB for RDRbased systems. In essence, in ROCHbased systems, for every application domain, experts construct cases (and, eventually, enter rules and their corresponding cornerstone cases) by using a conceptual hierarchy, namely, ROCH, which is created and maintained by the experts themselves. Such a hierarchy includes both ISA and PARTOF relationships and, although it must be established by the experts, it is verified by the system. For instance, consider the following example (extracted from MartínezBéjar et al. 1997b).
Suppose that an expert wishes to create a RDR system from the following pair of ripple down rules (expressed in natural language) R(t_{i}) = {"If the vegetation is very short, there is only one stratum and the seasonal variation is medium, then the area under study has got a low visual fragility (VF)", "If there exists a predominance of pine merged with stone outcrops then the area under study has got a high visual quality (VQ)"} = {r_{1}, r_{2}}. Let us also assume that there is no conceptualisation yet (as the expert wants to create a KB). Then, the expert would establish the following conceptual hierarchy in two steps (corresponding to each rule):
Step 1 (for {r_{1}})
vegetation_landuse (VF)
PARTOF
natural_vegetation (height, number_of_strata,seasonal_variation)
Step 2 (for {r_{1}, r_{2} })
vegetation_landuse (VF, VQ)
PARTOF
natural_vegetation (height, number_of_strata,seasonal_variation)
ISA
pine (merging_with_stone_outcrops, predominance)
where the information into brackets after each concept stands for the properties associated to it. At this point, after the system verifies that this conceptual hierarchy is consistent (for example, by ensuring that inheritance properties hold among their ISA nodes), the system could compound the rules to be incorporated in the KB.
In short, the goal of this work is to extend the RDR approach applicability, so that a more variety of forms for expressing the domain knowledge can be addressed. In particular, the fundamental purpose here is to extend in a stepbystep process the exclusive, restrictive model of knowledge acquisition/representation contemplated in ROCHbased systems (that is, the classical "if ..then" rule with crisp values) to deal with fuzzy domains in a more natural manner from the experts' view.
In this paper, we will make use of some basic concepts used in fuzzy logic that allow to address the problem of how to represent knowledge underlying fuzzy domains. However, although our work is not intended to be situated in the approximated reasoning field, some particular characteristics of the RDR philosophy (e. g., that experts are in charge of performing the KA process) should be taken into account when acquiring/representing this kind of knowledge.
Fuzzy logic, which has widely been used for representing imprecise knowledge in expert systems (Baldwin and Pilsworth, 1980; Zadeh, 1983; Yager, 1984; Sugeno, 1985; Kandel, 1990; LopezDe mantaras, 1990; Watanabe, 1991; Baldwin, 1992; Grabot et al., 1994), is basically a method to allow a gradual representation of likeness between two objects. It is based on the theory of fuzzy sets (Zadeh, 1965), which defines a membership function to assign a grade of membership between 0 and 1 to each element in the range of all possible elements under consideration. This grade can be thought as a measure of compatibility between the element and the concept represented by the fuzzy set. Formally, the membership function for a fuzzy set A, written m _{A}(x), is a real valued function defined as the application m _{A}: X ® [0,1] for all x in a universal set X.
Fuzzy sets are used to model the vagueness and imprecision present in natural language. Thus, they can be employed to represent concepts such as rarely and often. These terms are usually known as linguistic quantifiers and are very common in natural language. The amount of vagueness can be regulated by means of the socalled modifiers or hedges, which act in combination with linguistic quantifiers. Examples of modifiers are more and very.
In order to make different applications possible, several kinds of inference should be allowed. In this sense, in this work the Generalised Modus Ponens (GMP) approach, which has been used by some successful expert systems (see, for example, Hwang (1995) or Gisolfi and Di Lascio (1995)) has been chosen. Such an approach provides a framework where different types of inference semantics can be supported.
Through the GMP technique, the proposition y is B can be derived from the rule "if (x is A) then (y is B)" when the proposition x is A is true. The GMP can also be employed when the two propositions x is A and y is B are defined imprecisely. Thus, if a proposition x is A’, close to x is A, is true, the principle of the GMP is to derive another proposition, written y is B’. This proposition is generated by taking into account both the underlying semantics of the implication of the rule and a measure of the likeness between A and A’. With all, the inference consists of defining a fuzzy set B’ which is as close to B as A’ is to A. More formally, Dubois and Prade (1988) have computed the membership function of B’, written m _{B’}, as follows:
" y Î Y, m _{B’}(y) = sup_{x }Î X T(m _{A’}(x), (x ® y))
where
Y is the referential of y;
X is the referential of x;
T is a triangular norm that makes the GMP compatible with the classical modus ponens;
m _{A’} is the membership function of A’; and
(x ® y) represents an implication denoting the kind of causal link involved in the production rule.
According to Buckley et al. (1986), a fuzzy expert system (FES) must hold the following :
More formally, every FES can be characterised by the following:
A number of FESs have been successfully implemented todate. Examples of these can be found in Adlassnig et al. (1985), Binaghi et al. (1993), FathiTorbaghan and Meyer (1994), Gisolfi and Di Lascio (1995), Hwang (1995), Daniels et al (1997) and MartínezBéjar et al. (1997a). Some of the quoted systems use gausssian models for defining membership functions (Zadeh, 1983). These are particularly interesting when the usual values given to the fuzzy terms employed by experts can be represented by means of a triple (T) such as <low, medium, high>, <short, medium, high>, etc. We will term to each component of T as T_{l}, T_{m}, and T_{r}, respectively. Given a triple T, the formal definition of the mentioned functions is the following:
(1)

(2) 
(3) 
Where b = (a + g )/2;

For example, the fuzzy set dense_pineland can be represented by means of the functions T_{l}(x), T_{m}(X) and T_{r}(x) where a = 70 and g = 90.
Usually, the fuzzy terms to be modelled are adjectives, which can be preceded by fuzzy modifiers such as "very", "not", etc. This problem is addressed in the following example. Let us consider the sentence "the vegetation density is high" where the term "high" is represented by a continuous fuzzy function. Suppose now that the modifier "very" transforms "high" into another continuous fuzzy function so that sentences such as "the vegetation density is very high" are allowed by the system where the expression "the vegetation density" can take values from a fuzzy term denoted as "high". In this situation, the socalled TFM function (Kandel, 1990) has demonstrated to be useful (see, for example, Gisolfi and DiLascio (1995)). This function works as follows:
Let D be a fuzzy set, and let m be a truth modifier. Then, the result of modifying D by means of m, written TFM(D/m), is a fuzzy set, written mD, such as m _{mD}(x) = m _{m}(D(x)) where the m _{S}(V) function stands for the membership degree of the variable V with respect to the set S.
A practical example of the use of that function is the one pointed out in MartínezBéjar et al. (1997a). In this case, we have modelled the vague predicates containing modifiers by using the next TFM function:
(4) m _{mD}(x) = m _{m}[ D(x)] d
where
0 < d < 1 if the modifier m makes D to hold in a weak way. Examples are more or less, almost, little and few.
d > 1 if the modifier m makes D to hold clearly. Examples are lot, very, much and extremely.
Although, as it has been pointed out already, in this paper ROCHbased systems are used instead of classical RDR, problems still remain if one wants to apply the RDR philosophy to fuzzy domains. Firstly, ROCHbased systems can only operate with crisp values for the attributes in their rules. Nevertheless, fuzzy domains are typically concerned with rules following the next format:
IF (X_{ 1} is V_{ 1}) and (X_{ 2} is V_{ 2}) and .....and (X_{ n} is V_{ n}) then Y is A_{ }
where
X_{ i} stands for the ith variable (i.e., the ith attribute associated to a particular concept) to be taken into account; i = 1, 2, .., n;
n = number of subconditions present in the rule under question;
V_{ i} represent the value associated to X_{ i} . This can be either a crisp value or a fuzzy function;
Y stands for the variable associated to the conclusion of the rule;
A represents the value associated to Y. This value can be either a crisp value or a fuzzy function.
It could be argued that a "fuzzy" ripple down rule can always be substituted by a set of "crisp" ripple down rules. However, in general, using imprecise rules for describing situations very close each other allows to represent the underlying knowledge in a more adequate, efficient way (Grabot and Caillaud, 1996). For instance, let us consider the problem of inferring the possible landscape visual quality from the vegetation diversity that such landscape presents. This expertise could be described in a discrete way through a set of rules as follows:
R_{1}: If (vegetation.diversity = 10) then (landscape.visual_quality = 5%);
R_{2}: If (vegetation.diversity = 20) then (landscape.visual_quality = 22%);
...
R_{n}: If (vegetation.diversity = 10.000) then (landscape.visual_quality = 100%).
If knowledge is represented in this manner, the influence of other factors, for example vegetation density, can result in a variation of the landscape visual quality. Hence, the connection between the antecedent and the conclusion is eventually less evident than that present in an imprecise rule. In addition to this, it should be noticed that to cover the variation field of the vegetation diversity, a number of rules would be necessary.
Another way of expressing that experience could be the following:
R_{1}: If (vegetation.diversity < 10) then (landscape.visual_quality < 5%);
R_{2}: If (10 < vegetation.diversity < 20) then (6% < landscape.visual_quality < 22%);
...
R_{n}: If (vegetation.diversity > 9.999) then (landscape.visual_quality = 100%).
Notice that this way to describe the expertise involves imprecision, since it employs intervals rather than precise values. Besides, this approach introduces subjective threshold, so that it is necessary to have many arbitrary thresholds to obtain a good precision. On the contrary, fuzzy logic allows to represent this knowledge by means of a unique rule and, hence, to reduce the negative effect of the use of arbitrary thresholds. For example, such a rule could be "if (vegetation.diversity is high) then (landscape.visual_quality is high)".
Although, as it has already been pointed out, the research topics addressed in this work are intended to be far from those of fuzzy logic or fuzzy sets, most existent approaches to fuzzy modifiers/quantifiers have been conceived to allow for automated fuzzy reasoning in the systems where they have been applied (Baldwin and Pilsworth, 1980; Adlassing and Kolarz, 1982; Kandel, 1990; LopezDe Mantaras, 1990; Gisolfi and DiLascio, 1995; Grabot and Caillaud, 1996; Daniels et al., 1997). Thus, in these approaches modifiers/quantifiers are modelled by the system itself.
However, we think that in RDR the experts must be in charge of such a task according to their particular criteria, the system being only concerned with guaranteeing consistency. This has been the foundation for proposing an expertdriven policy for modelling fuzzy modifiers and fuzzy frequency quantifiers.
With all, a model, which can be used not only for ROCHbased systems, to manipulate fuzzy modifiers and fuzzy frequency quantifiers is formally formulated in the following lines.
3.3.1 Modelling of fuzzy modifiers
As it has been pointed out in Section 3.1, fuzzy attributes may be preceded by fuzzy modifiers, to which the TFM function (Kandel, 1990) can be applied. However, there are many different linguistic modifiers that could potentially be used by the experts when they create or maintain the system. In this sense, fuzzy modifiers used by experts independently of the application domain can be considered. Moreover, they can be grouped into several sets attending to their modification intensity. For instance, a possible fuzzy modifiers classification, which will be considered further in this work, is the following:
a) "Positive" sets of modifiers
RADICAL_POSITIVES = P1 = {"completely", "extremely", "radically", "absolutely", "totally",..};
MODERATE_POSITIVES = P2 = {"very", "much", "lot", "quite",..};
b)"Negative" sets of modifiers
RADICAL_NEGATIVES = N1 = {"almost nothing", "hardly",.. };
MODERATE_NEGATIVES = N2 = {"little", "bit", "few", "more or less", "almost",..};
c)Set of "isnot" forms
IS_NOT = {"not", "not at all", "nothing" "completely not", "practically not", "absolutely not", "practically nothing",..}.
Once the possible modifiers to be used have been classified into sets, experts can be shown all these sets into which they can include the modifiers, if any, when they construct cases or rules through a ROCH.
On the other hand, it can be noticed that the modifiers belonging to N_{i} (P_{i}) are more intense that those belonging to N_{j} (P_{j}) if i < j; i, j = 1, 2. By taking this into account and by employing the TFM function used in Section 3.1, if it is assumed that fuzzy modifiers act on any of the elements of the triple < T_{l}(x), T_{m}(x), T_{r}(x)>, the following modelling criterion has been adopted.
Let m _{mT}(x) be the membership degree of the variable x with respect to the set mT_{i}, where m Î P È N È IS_NOT, P = , N = ; i Î {l, m, r}; and n_{p} and n_{n} stand for the number of positive and negative nonempty sets of modifiers, respectively. Then, m _{mT}(x) can be defined as follows:
(5) m _{mT}(x) =
In order to give an appropriate value to the parameter d , it must be taken into account that all the elements included in the negative sets of modifiers affect T_{i}(x) in a different manner as those included in the positive ones. In particular, and by considering the equations defining T_{i}(x), if the modifier belongs to any of the negative sets of modifiers, the values for d should imply a greater membership function than T_{i}(x). Similarly, if the modifier belongs to any of the positive sets of modifiers, the values for d should imply a less membership function than T_{i}(x).
With all, d can be defined as follows: (6)
Where: (7) , i Î {1,.., n_{p}}; (8) , i Î {1,.., n_{n}},
For example, if we consider the above sets of modifiers, (6) can be applied with n_{p} = n_{n} = 2 and, then, d can be defined as follows:
(7.1) , i Î {1, 2}; (7.2), i Î {1, 2}
3.3.2 Modelling of fuzzy frequency quantifiers
It should also be taken into account that there are linguistic fuzzy quantifiers referred to as frequency quantifiers, for example, always, seldom, etc. Hence, they have not been contemplated in any of the modifiers sets above defined. Moreover, fuzzy modifiers can be combined with the referred fuzzy modifiers in linguistic expressions, for example "A is seldom very high". Therefore, it is an interesting endeavour to attempt to model how these quantifiers act on a fuzzy attribute, which in turn, can be preceded by a fuzzy modifier. In this sense, and by reasoning as before for fuzzy modifiers, various sets integrating linguistic quantifiers according to their frequency intensity can be formed. A classification of such quantifiers is, for instance, the following:
HIGH_FREQUENCIES = H= {"almost always", "very often", "often",..}= {h_{1}, h_{2}, h_{3},..};
LOW_ FREQUENCIES = L = {"almost never", "very seldom", "seldom",..}= {l_{1}, l_{2}, l_{3},..};
FACTS = F = {"always"};
IMPOSIBLE_FACTS = I = {"never"}.
Notice that H and L can be disposed in such a way that they can become ordered sets (as, in fact, the above sets are) in the sense that h_{i} produces more frequency that h_{j} if i < j, while l_{i} produces less frequency that l_{j} if i < j; i, j = 1,..,3. Moreover, a method to obtain representative numerical values for some linguistic quantifiers has been proposed by Adlassnig and Kolarz (1982), as Table 1 illustrates .
always 1.00 
almost always 0.99 
very often 0.90 
often 0.75 
seldom 0.25 
very seldom 0.10 
almost never 0.01 
never 0.00 
Table 1. Representative numerical values for some linguistic quantifiers
However, it can be noticed that the values these authors propose are limited to the fuzzy quantifiers present in the table. Thus, if some new fuzzy quantifier is pretended to be added, several options can be adopted. Thus, the input fuzzy quantifier may be approximated to one of those contained in the table. Also, some other approximation that can generate a representative numerical value, which depends on the quantifier under question, can be considered.
In the case of ROCHbased systems, given that the experts are in charge of performing both the KA and the maintenance processes, they should have the possibility of choosing in which set amongst the above ones to insert the quantifiers, if any, when they enter cases or rules to the system. In addition to this, as it can be noted, representative numerical values for quantifiers in Table 1, depend on the intensity. With all, a mechanism to generate the values to be given to quantifiers can be defined. For it, it should also be taken into account that the size of the anterior quantifier sets must be considered in order to select the distances among these values. Such a mechanism is formally exposed in the following lines.
Let m _{qmT}(x) be the membership degree of the variable x with respect to the set qmT_{i}, where m and T_{i}(x) are defined as before and the frequency factor, written q, belongs to the union set H È L È F È I, all of these sets being nonempty and finite. Then, m _{qmT}(x) can be defined as follows:
(9) m _{qmT}(x) = qm _{mT}(x)^{ }where
(10)
(11), CH = Card(H) + 2; (12), CL = Card(L) + 2.
For instance, by using the sets of frequency quantifiers defined above, (10), (11) and (12) can be defined as follows:
(10.1)
(11.1) (12.1)
By assuming that the membership functions for fuzzy attributes respond to the model of the triple <T_{l}(x), T_{m}(x),T_{r}(x)> as indicated earlier, and that experts can effectively be aware about the fact that they can represent their knowledge in this way, these attributes can be defined as a function of two different parameters, namely, a and g (obviously, in addition to the linguistic terms that univocally identify that attribute). In so doing, we might also provide the experts with the possibility of defining these numbers with confidence intervals, as it frequently happens in real life. Moreover, the possible presence of modifiers or frequency quantifiers in their jargon can also be considered. With all, and by taking into account the notation employed until now, the next definition concerning the application of ripple down rules to fuzzy domains is proposed.
Definition 1: FROCHbased system
Let R be a ROCHbased system. R is said to be a fuzzy ripple down rulesoriented conceptual hierarchies (FROCH)based system, written FROCHbased system, if the rules can be applied to fuzzy domains by modelling fuzzy attributes, fuzzy modifiers and fuzzy quantifiers as it has been established in this Section, so that every valued attribute, written VA, is represented as follows:
the elements into brackets standing for optional elements in the representation, that is, they can be present or not in the attribute structure, depending on whether the experts make use of them in the description of input cases, and where
concept stands for the identifier concept in the FROCH for which VA is valued;
attribute is the identifier employed for VA;
a and g are the parameters necessary for defining three membership functions for VA according to the triple <T_{l}(x), T_{m}(x),T_{r}(x)>;
Ia and Ig stand for the confidence intervals given by the expert for a and respectively, and holding that Ia , Ig Î (0, 50%);
quantifier represents an element of the union set H È L È F È I;
modifier represents an element of the union set P È N È IS_NOT;
fuzzy_value represents a fuzzy value given to VA according to what any of functions in the triple <T_{l}(x), T_{m}(x),T_{r}(x)> represents , that is, high, medium, normal, low, short, tall, etc.
R represents a mathematical relationship, including equality, order and membership, among the underlying attribute (i.e., the VA) and the elements of the set{crisp_value_{1}, crisp_value_{2},.., crisp_value_{n}};
crisp_value_{i}, represents the ith nonfuzzy value for VA, 1 £ i £ n.
With RDRbased systems, the KA process is performed while the expert is maintaining the system, as it has been pointed out in Section 2. In addition, as MCRDR makes possible to have multiple independent conclusions, we will assume that the implicit problemsolving method in FROCHbased systems will be that of MCRDR. So, the KA process, will essentially be the same as that used in MCRDR. To be precise, by using FROCHbased systems, the KA process will consist of performing the following steps:
(S1) The expert builds an input case through the FROCH.
(S2) The system runs the input case, that is, this is confronted to the rules present in the KB.
(S3) The system shows the conclusions, if any, obtained (acquired) by the system for the input case in such a way that all rule traces are stored.
(S4) If the expert disagrees with some of these conclusions or is missing a conclusion (by assuming that no conclusion is the default), after inference, the system retrieves information regarding the cornerstone case associated to each rule that provided a wrong conclusion together with information about the input case. Then, the knowledge acquisition process will proceed as follows:
(S4.1) The system acquires the correct conclusions from the expert.
(S4.2) The system decides on the location of the rules to be entered by the expert.
(S4.3) The system acquires new rules from the expert and adds them in order to correct the KB.
Regarding the steps to be followed in the KA process in a FROCHbased system once an input case has been constructed from a FROCH, several issues should be addressed. Firstly, to accomplish the step (S1), that is, to construct an input case from a FROCH, a different mechanism from that of ROCH must be defined, since some conditions in the case could be fuzzy valued attributes. Secondly, a compatibility mechanism to confront an eventual fuzzy ripple down rule with a case that can be expressed by means of (some) fuzzy valued attribute must be provided. Furthermore, such a mechanism should also address the problem of defining the criteria to match a condition having the fuzzy valued attribute format against another condition which could not have such a format (i. e., it could be a crisp condition).
Thirdly, given the representation schema for fuzzy valued attributes adopted in this paper, to carry out the step (S3), the system must contemplate the possibility that several conclusions about the same valued attribute could be generated. In this case, the system must have a mechanism to help the expert to select a unique conclusion concerning the same fuzzy attribute, by taking into account all the possible candidate conclusions. Fourthly, if the input case or the cornerstone case implied in the addition of a new rule (see step (S4.3)) contains some fuzzy valued attribute, the way in which the system constructs difference lists must also consider all the parameters and elements involved in the representation for such attributes.
With all, the problems derived from the implications of using fuzzy valued attributes when performing the KA (as indicated above) with FROCHbased systems are analysed in the following Sections.
In addition to the possibilities that ROCHs offer to construct cases from a conceptual hierarchy, in FROCHs, the expert must have a way to account for the fuzzy values and the parameters defining an eventual fuzzy valued attribute when he or she is constructing an input case. Moreover, the experts can also have the necessity of considering fuzzy modifiers or fuzzy frequency quantifiers. In this sense, according to the definition given for FROCHbased systems, all the referred parameters and elements have been defined in the framework of a model put forward in the anterior Section, so that the expert can make use of that model in the input cases construction mechanism, which is explicated in the following.
First of all, one possible policy is that the expert could define a fuzzy attribute, through the parameters and elements explained before, every time he or she wants to use it in an input case. This would guarantee that each input case would use the correct (exact) definition, according to the experts’ criterion, for fuzzy definitions of attributes. However, it can be noticed that, if we take into account the FROCHbased definition, a fuzzy valued attribute involves, in turn, the definition of two parameters (i. e., a and g ). Furthermore, the expert could also use confidence intervals for a or g , or one fuzzy frequency modifier or one fuzzy modifier. Now, if the same fuzzy attribute is supposed to take part of several input cases, what is normal in real world, the quoted policy would lead to a very inefficient system.
On the other hand, it is reasonable to think that, in the context of a maintenance session, the definitions provided by the expert for the same attribute (associated to the same concept in the FROCH) will be kept across different input cases. This assumption has been crucial for the criterion adopted here, which is exposed in the following lines.
In this work, it is proposed that, whenever the expert wishes to construct a fuzzy valued attribute not used yet (for the same concept) in the conceptual hierarchy during the FROCHbased system maintenance session in course, the system must prompt the expert to enter a triple <T_{l}, T_{m}, T_{r}>, whose elements are words different one another and corresponding to the three possible fuzzy values as indicated in (1), (2) and (3), respectively. In addition to this, the expert must include in these the value, which is intended to have the fuzzy attribute under question. Furthermore, two real numbers (and, optionally, their respective confidence intervals), corresponding to the points where the membership functions T_{l} and T_{r}, respectively, reach the value 1 (that is, a and g ), must be provided by the expert. However, if the fuzzy attribute corresponding to the same involved concept was already used to construct a case in the current maintenance session, all what the expert will have to do is to select, amongst T_{l}, T_{m} and T_{r}, the fuzzy value for the current input case.
In addition, if the expert wants to use a fuzzy modifier to construct a fuzzy valued attribute (i. e., a fuzzy condition) in an input case, in the system here proposed, he or she will be shown a bydefault classification of such modifiers that can be modified at anytime by him or by her. In particular, the expert will be shown the modifiers sets, which have been established in (5), containing several elements, so that these can be renamed or removed. In addition to this, new elements can be added to such sets. With all, once the expert has finished introducing modifications, if any, to the current disposition of modifiers, these will be shown to him or to her every time he or she wishes to make use of fuzzy modifiers during the session in course. Besides, when the expert identifies (or enters) a fuzzy modifier to be used, the system will record the modifiers set to which such a modifier belongs for further processing of the input case in which such a modifier was used (or entered).
To end, with respect to fuzzy frequency quantifiers, a similar modus operand to that employed for fuzzy modifiers is proposed. The nuance to be considered with such quantifiers stems from the fact that the system will also take into account the position that every quantifier possesses in a particular quantifier set, according to the fuzzy quantifiers modelling pointed out in the anterior Section. Hence, when the expert wants to use a fuzzy quantifier, which is not present in any of the quantifiers sets yet, he or she must provide the system with more information. To be precise, in addition to identifying the set in which the new quantifier should be included, the expert must also consider the order of frequency relative to any of the other elements (that is, to state whether the new quantifier implies more or less frequency than another one) that already take part of the set under question. The reason for requiring this information is that fuzzy frequency quantifiers have been modelled according to an ordered setsbased classification (see Section 3).
In order to compare an input case and a rule belonging to the KB, some explicit policy should be adopted in relation to how to match conditions that can involve fuzzy valued attributes defined as indicated earlier. Notice that, if a simple characters string recognition strategy is applied in order to check whether two conditions, which can involve fuzzy valued attributes, are or not the same, some problems can arise. Thus, every expert may give his or her particular definition of certain fuzzy attribute. Furthermore, depending on the (input) case, the same expert could use different definitions for the same fuzzy valued attribute or, what is more significant, he or she could define the underlying attribute as a fuzzy valued one or as a crisp valued one indistinctly. So, the pattern recognition solution can lead to a very inefficient, incomprehensible system, since many definitions with minimal differences among them might be given for the same fuzzy valued attribute.
For example, suppose that the KB contains a rule, written R, defined as "if vegetation.density(1,80) is seldom very high then C". In addition to this, let us assume that the expert who is in charge of maintaining the system, to whom we will call E, is different from the one who entered the cornerstone case containing the condition expressed in R, to whom we will call E’. In this case, by assuming that E wishes to use a fuzzy format for the attribute under question, he or she must define vegetation.density in an hypothetical input case exactly as E’ did in R in order to allow an eventual matching between R and the input case.
As it has been put forward, the same attribute for a given concept can be defined as fuzzy or as crisp (depending on the input case) in FROCHbased systems. This has been taken into account for defining a criterion on which the matching process will be based. In particular, we will define first the matching criterion involving two fuzzy valued attributes corresponding to one of the conditions of the input case and to one of the rules of the KB, respectively. After, by applying some results obtained in the definition of this criterion, we will deal with the problem of having a crisp valued attribute against a fuzzy valued one in the case running process.
Attending to the FROCHbased system definition, some compatibility criterion among two whatever definitions of a fuzzy valued attribute could be defined. More precisely, this criterion can be established by taking into account both the information about the parameters defining the underlying membership functions(i.e., a , g and their respective confidence intervals) and the elements of the attribute definition (i. e, the quantifier, the modifier, and the fuzzy value) involving the two fuzzy valued attributes under question. For it, the semantic distance among the elements or parameters implied in a comparison has been considered as a basic factor.
Formally, the referred criterion can be stated in a stepbystep process as it is explicated in the following definitions.
First of all, we can group the values associated to each membership function integrating the triple referenced before into semantic compatibility classes by taking into account, for example, that the linguistic tags associated to T_{l}(x) and T_{r}(x), respectively, should be different, that is, they should not overlap from the semantic point of view. Formally, the referred classification can be established as follows.
Definition 2: compatible/incompatible fuzzy values
Let < T_{1}, T_{2}, T_{3}> be a triple containing three different linguistic tags associated to the elements of the triple < T_{l}(x), T_{m}(x), T_{r}(x)> and defined according to (1), (2) and (3), respectively; and let V_{1 }and V_{2 }be two elements belonging to the union set . V_{1} and V_{2} are said to be two compatible fuzzy values, written compatible_values (V_{1}, V_{2}), if the following holds:
where V_{12} = {V_{1}}È {V_{2}}.
Otherwise, that is, if the above condition does not hold, p_{1} and p_{2} are said to be two incompatible fuzzy values, written incompatible_values (V_{1}, V_{2}).
Definition 3: left/right side membership functions
Let (a _{f}, g _{f}) be the parameters corresponding to the definition of a fuzzy attribute, written FVA, in a FROCHbased system. Consider also the triple < T_{l}(x), T_{m}(x), T_{r}(x)>, defined according to (1), (2) and (3), respectively. The leftside membership functions associated to (a _{f}, g _{f}), written left_side_mf(a _{f}, g _{f}), is defined as the set {T_{l}(x), T_{m}(x)}in the interval [a _{f}, b _{f}].
Similarly, the rightside membership functions associated to (a _{f}, g _{f}), written right_side_mf(a _{f}, g _{f}), is defined as the set {T_{m}(x), T_{r}(x)}in the interval [b _{f}, g _{f}].
Definition 4: maximum parameterbased compatibility distance
Let (a _{f}, g _{f}) be the parameters corresponding to the definition of a fuzzy attribute, written FA, in a FROCHbased system; let L = (l_{1}, l_{2}) be the set of linguistic tags associated to those of leftside_mf(a _{f}, g _{f}); and let R = (r_{1}, r_{2}) be the set of linguistic tags associated to those of rightside_mf(a _{f}, g _{f}). The maximum parameterbased compatibility distance for FA, written MPCD, is defined as a real number such that [LEFT_COMPATIBILITY(a _{f}, g _{f}, MPCD) and RIGHT_COMPATIBILITY(a _{f}, g _{f}, MPCD)] holds where
LEFT_COMPATIBILITY(a _{f}, g _{f}, MPCD) = [" x Î [b _{f}  MPCD, b _{f}] $ l_{ i} Î L such that (x) ³ m _{r}(x) where (r Î R) and (r Ï L);
RIGHT_COMPATIBILITY(a _{f}, g _{f}, MPCD) = [" x Î [b _{f}, b _{f} + MPCD] $ r_{ i} Î R such that (x) ³ m _{l}(x) where (l Î L) and (l Ï R); b _{f} = .
Lemma
Let (a _{f}, g _{f}) be the parameters corresponding to the definition of a fuzzy attribute in a FROCHbased system. Then, the following equality holds: MPCD = .
By applying the above lemma to the characteristics of the fuzzy memberships functions underlying a FROCHbased system, the following definitions can be written.
Definition 5: parameterbased compatibility range
Let p be a parameter defining a fuzzy membership function associated to a fuzzy valued attribute, written FVA, in a FROCHbased system; and let MPCD be the maximum parameterbased compatibility distance for FVA. The parameterbased compatibility range for p, written PCR(p), is defined as the interval [p  MPCD, p + MPCD].
Definition 6: parameterbased compatibility
Let p, p’ be belonging to the set {a _{f}, b _{f} , g _{f}}, and whose elements are the parameters that define the fuzzy memberships functions T_{l}(x), T_{m}(x) and T_{r}(x), respectively for certain fuzzy attribute in a FROCHbased system; and let PCR(p) the parameterbased compatibility range for p. p’ is said to be compatible with respect to p, written compatible_parameters (p, p’), if p’ Î PCR(p).
It can be noticed that, attending to the previous corollaries, one could argue that if one wants to know the parameters, which are compatible with respect to b _{f}, some redundancy would be produced as there are two statements asserting this compatibility. To avoid this kind of notation redundancies, we can write the compatibility respect to b _{f} by using a new notation.
Definition 7: relative parameterbased compatibility
Let p, p_{i} , 1 £ i £ n, be two parameters defining a fuzzy membership function for a fuzzy valued attribute in a FROCHbased system such that the following holds: compatible_parameters(p, p_{1}) and compatible_parameters(p, p_{2}) and...and compatible_parameters(p, p_{n}). The parameterbased compatibility relative to p, written relative_compatibility(p), is defined as the set { p_{1} , p_{2},.., p_{n}}.
So far, we have formally established the definitions and use of compatibility classes into a same fuzzy attribute according to its definition parameters (that is, a and g ). However, the objective pursued in this subsection is more ambitious in that we attempt to establish a compatibility criterion between two fuzzy attributes in a FROCHbased system. To reach this goal, we can establish some principles, which will constitute the foundation for a further definition of the referred criterion.
Firstly, we can extend the maximum parameterbased compatibility distance concept to the case of two (in general) different fuzzy attributes. For it, we will take into account the following principle.
Principle 1: maximum distance
Let f_{1} and f_{2} be two fuzzy valued attributes belonging to a FROCHbased system, and defined, respectively, as "concept.attribute(a _{i}, g _{i})". A necessary condition for f_{1} and f_{2} to be semantically compatible is that p_{j} Î PCR(p_{k}), where p_{j} Î {a _{j}, b _{j}, g _{j}); p_{k} Î {a _{k}, b _{k}, g _{k}}; b _{i} = ; i, j, k = 1, 2.
Secondly, by considering what definition 2 states, we can restrict the parameters that could potentially be semantically intercompatible to those whose values belong to the same class.
Principle 2: nonincompatible values
Let f_{1} and f_{2} be two fuzzy valued attributes belonging to a FROCHbased system, and defined, respectively, as "concept.attribute(a _{i}, g _{i}) is value_{i}", i = 1, 2. A necessary condition for f_{1} and f_{2} to be semantically compatible is that compatible_values (value_{1}, value_{2}).
By analysing the two compatibility classes defined above, it is easy to note that the two geometrical regions where such classes exist have interesting properties respect to the values that the respective membership functions involved in them take. This fact can be expressed in a formal stepbystep process as follows.
From what has bee considered so far, someone could argue that a criterion about the semantic compatibility between two fuzzy valued attributes, where the difference is only in the parameters or in the values, can be derived from the logic conjunction of the two principles indicated earlier. This idea can be founded on the fact that all the soobtained results can be applied to many situations. Consider, for example, the distributions ((a)  (e)) shown in Figure 1.
It can be noted that all the cases (a)  (e) in Figure 2 hold the two principles mentioned previously. Moreover, by applying Definition 6 to each of the above cases, the following is obtained:
(a) relative_comp(a _{1}) = {a _{2}, b _{1}}; relative_comp(g _{1}) = {b _{1}, b _{2}, g _{2}};
(b) relative_comp(a _{1}) = {b _{1}, a _{2}, b _{2}}; relative_comp(g _{1}) = {b _{1}, g _{2}};
(c) relative_comp(a _{1}) = {b _{1}, a _{2}}; relative_comp(g _{1}) = {b _{1}, b _{2}, g _{2}};
(d) relative_comp(a _{1}) = {b _{1}, a _{2}, b _{2}}; relative_comp(g _{1}) = {b _{1}, g _{2}};
(e) relative_comp(a _{1}) = {b _{1}, a _{2}, b _{2}}; relative_comp(g _{1}) = {b _{1}, g _{2}}.
However, problems still remain when one of those fuzzy valued attributes is composed by parameters very close each other and, in turn, all of them being very far from one of the pairs (a , g ). Figure 2 illustrates this phenomenon. Besides, when this occurs, although the two necessary conditions underlying Principle 1 and Principle 2, respectively, hold, it seems not to be reasonable to consider the possibility of the two fuzzy valued attributes under question to be compatible.
Figure 2. Accumulation of parameters.
Formally, this situation can be expressed in the following principle:
Principle 3: maximum distance
Let f_{1} and f_{2} be two fuzzy valued attributes belonging to a FROCHbased system, and defined, respectively, as "concept.attribute(a _{i}, g _{i}) is value_{i}"; and let MPCD_{i} be the maximum parametric compatibility distance for f_{i}, i = 1, 2. A necessary condition for f_{1} and f_{2} to be semantically compatible is that the following holds:
{[(g _{j} £ g _{k}) and (a _{j} ³ a _{k})] ® (MPCD_{j} ³ K_{ j}* MPCD_{k})}, j¹ k = 1,2
where
K_{ j} = min{b _{j}  MAXa _{j}, MINg _{j}  b _{j}};
MAXa _{j} = MINg _{j} =
Based on the three principles exposed before, the following definition can be derived:
Definition 8: compatible/ incompatible definition parameters
Let f_{1} and f_{2} be two fuzzy valued attributes belonging to a FROCHbased system, and defined, respectively, as "concept.attribute(a _{k}[Ia _{k}] , g _{k}[ Ig _{k}] ) is value_{k}"; let p_{k} be (a _{k}, g _{k}); let K_{j} be in accordance with Principle 3; and let MPCD_{k} be the maximum parametric compatibility distance for f_{k}, k = 1, 2. p_{1} and p_{2} are said to be compatible definition parameters, written compatible_parameters (p_{1}, p_{2}) if (compatible_values(value_{1}, value_{2})) and (within_compatible_ranges(p_{i}, p_{j})) and (sufficient_distance(p_{i}, p_{j})) holds, where
within_compatible_ranges(p_{i}, p_{j}) = ;
sufficient_distance(p_{i}, p_{j}) =
Now, if we go one step beyond, in the sense of considering also fuzzy frequency quantifiers, another designing principle, operating on the frequency sets pointed out in Section 3, can be established.
Principle 4: frequency compatibility
A fuzzy frequency quantifier belonging to the I È L must not be considered as semantically compatible to another one not belonging to such a union set.
The above principle can be used to formally define the compatibility it alludes to as follows:
Definition 9: compatible/ incompatible fuzzy frequency quantifiers
Let q_{1} and q_{2} be two fuzzy frequency quantifiers such that q_{k} belongs to the union set H È L È F È I È UN_{q}, k = 1, 2; where H, L, F and I respond to the definition given in (9), while UN_{q} stands for the fact that some quantifier is unspecified. So, UN_{q} can be expressed as the set {"unspecified_quantifier"}. Moreover, we will assume that an unspecified quantifier is a synonym concept of "always". Under these conditions, q_{1} and q_{2} are said to be two compatible fuzzy frequency quantifiers, written compatible_quantifiers(q_{1}, q_{2}), if the following logic condition holds:
[(q_{12} Í INFERIOR_FREQS) or (q_{12} Í SUPERIOR_FREQS)]
where
q_{12} = {q_{1}}È {q_{2}}; INFERIOR_FREQS = (I È L); SUPERIOR_FREQS = (F È H È UN_{q}).
Otherwise, that is, if the above logic equation does not hold, q_{1} and q_{2} are said to be two incompatible fuzzy frequency quantifiers, written incompatible_quantifiers(q_{1}, q_{2}).
The anterior principle can also be used when fuzzy modifiers are present in a fuzzy valued attribute. The nuance to be considered in this case is that a modifier can belong to several compatibility classes
Formally, the compatibility concerning fuzzy modifiers has been established by means of the following definition.
Definition 10: compatible/incompatible fuzzy modifiers
Let m_{1} and m_{2} be two fuzzy modifiers such that q_{k} belongs to the union set P È N È IS_NOT È UN_{m}, k = 1, 2; where P, N, and IS_NOT respond to the definition given in (5), while UN_{m} accounts for the fact that some modifier is unspecified. So, UN_{q} can be expressed as the set {"unspecified_modifier"}. Moreover, we will assume that the presence of an unspecified modifier means that the parameter d takes the value 1. Under these conditions, m_{1} and m_{2} are said to be two compatible modifiers, written compatible_modifiers(m_{1}, m_{2}), if the logic condition holds, where
M_{1}=; M_{2}=;
M_{3}=; M_{4} = ;
Otherwise, that is, if the above logic equation does not hold, q_{1} and q_{2} are said to be two incompatible fuzzy modifiers, written conflicitve_modifiers(q_{1}, q_{2}).
By considering the previous definitions, a compatibility/conflictivity criterion to be applied to eventually fuzzy valued attributes in the context of a FROCHbased system can be derived as follows.
Definition 11: compatible fuzzy valued attributes
Let FVA_{1} and FVA_{2} be two fuzzy valued attributes represented, according to definition 1, as "c_{i}.a_{i}(p_{i}) is [q_{i}] [ m_{i}] v_{i}" respectively, where p_{i} = (a _{i}[Ia _{i}] , g _{i}[Ig _{i}] ), i = 1, 2. FVA_{1} and FVA_{2} are said to be two compatible fuzzy valued attributes, written compatible_val_atts (FVA_{1}, FVA_{2}), if [(EQUAL_{12}) or ((EQUAL_ca (FVA_{1}, FVA_{2}) and (COMPATIBLE_vpmq (FVA_{1}, FVA_{2}))] holds, where
EQUAL_{12} = (FVA_{1} = FVA_{2});
EQUAL_ca (FVA_{1}, FVA_{2}) = (c_{1}.a_{1} = c_{2}.a_{2}); and
COMPATIBLE_vpmq (FVA_{1}, FVA_{2}) = [(compatible_parameters(p_{1}, p_{2})) and (compatible_modifiers(m_{1}, m_{2})) and (compatible_quantifiers(q_{1}, q_{2}))].
Similarly, the following definition can be established:
Definition 12: incompatible fuzzy valued attributes
Let FVA_{1} and FVA_{2} be two fuzzy valued attributes represented, according to definition 1, as "c_{i}.a_{i}(p_{i}) is q_{i}m_{i}v_{i}" respectively, where p_{i} = (a _{i}[Ia _{i}] , g _{i}[Ig _{i}] ), i = 1, 2. FVA_{1} and FVA_{2} are said to be two incompatible fuzzy valued attributes, written incompatible_val_atts (FVA_{1}, FVA_{2}), if [EQUAL_ca (FVA_{1}, FVA_{2}) and (NOT(COMPATIBLE_vpmq(FVA_{1}, FVA_{2}) )] holds, where EQUAL_ca (FVA_{1}, FVA_{2}) and COMPATIBLE_vpmq (FVA_{1}, FVA_{2}) are defined as in previous definition.
When a case is entered to a FROCHbased system, several situations can be distinguished, depending on the nature of the attributes implied in the matching process, namely, either fuzzy or crisp. Thus, the crisp valued attributes can respond to various formats. Here, we will consider the character stringbased one and the numeric intervalbased one. All these possibilities are analysed in the following lines.
6.2.1 Fuzzy valued attributes versus character stringlike valued attributes
A representative example of this situation can be "vegetation.height(5,40) is high versus vegetation.height = medium". By assuming that the same pair (concept, attribute) is referenced in both conditions, the criterion to be followed will consist of checking whether the values (and, eventually, the modifiers and the quantifiers) are compatible. Moreover, if they are found to be compatible and the rule involved in the comparison process possesses siblings in the MCRDR structure, the crisp valued attribute under question will be replaced by the fuzzy valued attribute in further comparisons for the current input case. In this way, given an input case, the matching process involving sibling rules will take place in a context of a more precise knowledge.
Formally, the compatibility criterion can be stated as follows:
Definition 13: compatible nonnumerical crisp valued attributes
Let FVA_{ 1} and CSVA_{ 2} be a fuzzy valued attribute and a character stringlike valued attribute in a FROCHbased system and represented, respectively, as follows :
FVA_{ 1} = "concept_{1}.attribute_{1}(p_{ 1}) is [q_{1}] [m_{1}] v_{1}"; CSVA_{ 2} = "concept_{2}.attribute_{2} = [q_{2}] [m_{2}] v_{2}"
Where p_{1} = (a _{1}[Ia _{1}] , g _{1}[Ig _{1}] )
FVA_{ 1} and CSVA_{ 2} are said to be scompatible, written scompatible(FVA_{ 1}, CSVA_{ 2}), if (concept_{1}.attribute_{1} = concept_{2}.attribute_{2}) and (compatible_values(v_{1}, v_{2})) and (compatible_modifiers(m_{1}, m_{2})) and (compatible_quantifiers(q_{1}, q_{2})) holds.
6.2.2 Fuzzy valued attributes versus numeric intervallike valued attributes
A typical example of this case is "height(5,40) is high versus height Î [5,12] ". By assuming that the same pair (concept, attribute) is referenced in both conditions, the system will check whether the interval underlying the crisp valued attribute under question is included in the definition of the fuzzy attribute. If so, the system will determine whether the linguistic tag referenced in the fuzzy attribute corresponds to the interval into which the interval associated to the crisp attribute can be allocated. Finally, the modifiers and the frequency quantifiers, if any, will be confronted to check compatibility. This entire process can be expressed in a formal manner in a stepbystep process as follows:
Definition 14: active interval
Let (a [Ia ] , g [Ig ] ) be a pair containing the parameters and their respective confidence intervals corresponding to the definition of a fuzzy attribute, written FVA, in a FROCHbased system; let < T_{1}, T_{2}, T_{3}> be a triple containing three different linguistic tags associated to the respective elements of the triple < T_{l}(x), T_{m}(x), T_{r}(x)>, defined according to (1), (2) and (3), respectively; let C, A be the concept and the attribute, respectively, underlying FVA.; and let v be the value defined in FVA such that v Î . The active interval for C.A in FVA, written active_interval (C.A, FVA) is defined as follows:
active_interval (C.A, FVA) =
where
MAXa = MAXg =
MINa = MINg =
Now, the following definition can be established:
Definition 15: compatible numeric crisp valued attribute
Let FVA_{ 1} and NIVA_{ 2} be a fuzzy valued attribute and a numeric intervallike valued attribute in a FROCHbased system and represented, respectively, as follows :
FVA_{ 1} = "concept_{1}.attribute_{1}(p_{ 1}) is [q_{1}] [m_{1}] v_{1}";
CSVA_{ 2} = "concept_{2}.attribute_{2} Î (v_{inf}, v_{sup})"
where
p_{1} = (a _{1}[Ia _{1}] , g _{1}[Ig _{1}] )
FVA_{ 1} and NIVA_{ 2} are said to be ncompatible, written ncompatible(FVA_{ 1}, NIVA_{ 2}), if (concept_{1}.attribute_{1} = concept_{2}.attribute_{2}) and (compatible_values(v_{1}, v_{2})) and (compatible_modifiers(m_{1}, m_{2})) and (compatible_quantifiers(q_{1}, q_{2})) and [(v_{inf}, v_{sup}) Î active_interval(concept_{1}.attribute_{1}, FVA_{ 1})] holds.
By using previous definitions, the condition for a given rule in a FROCHbased system to by fired by an input case, can be established as follows:
Definition 16: fired fuzzy ripple down rule
Let CR_{i} be a condition of a rule, written R; let CI_{j} be a condition for an input case, written I; and let CR_{i} and CI_{j }being respectively represented (according to the representation format adopted here for FROCHbased system) as follows:
C_{k} =
Where: C_{k} Î {CR_{k}, CI_{k}}; k Î {i, j}; p_{k} = (a _{k}[Ia _{k}] , g _{k}[Ig _{k}] ); n_{k} = number of values involved in c_{k}.a_{k}
R is said to be fired by I, written fired (R, I) if " CR_{i} Î R, $ CI_{j} Î I, such that compatible_valued_attributes(CR_{i}, CI_{j} ) holds Where:
compatible_valued_attributes (CR_{i}, CI_{j})=
match(CR_{i}, CI_{j}) =
R =; I = .
Once a rule has been fired by an input case, the expert will be shown the conclusion associated to such a rule. Thus, as it has been put forward earlier, since conclusions can also be represented by means of fuzzy valued attributes, a number of these ones concerning the same attribute might be produced. This problem is addressed in the next Section.
As it has been pointed out already in this work, if multiple conclusions are feasible in the system (that is, if it is an MCRDR system) and provided that they can encompass fuzzy valued attributes, semantic conflicts among valued attributes can arise when experts are shown a set of conclusions after running an input case. Similarly to the problem addressed in previous Section about how to define the matching conditions between an input case and a rule in a FROCHbased system, the system should have a mechanism for managing the situation where multiple conclusions about the same valued attributes are produced by the system.
If it is taken into account what has been put forward in Section 2, it can be said that the deeper in an MCRDR structure, the more refined the knowledge it contains. So, in case that multiple conclusions about the same attribute (for the same concept) are generated by the system, this factor (i. e., the conclusion depth in the rules base structure) should be considered. Besides, several conclusions alluding to the same feature at the same depth in the rule structure could be generated. If so, intercompatible conclusions can be grouped into compatibility classes. In this manner, a potential reduction of the expert’s task is achieved.
In addition to grouping the conclusions into compatibility classes, we can make use of the possibilities that fuzzy logic offers to help the experts to decide which conclusion concerning a certain feature should be considered by assuming that the conclusions under consideration are allocated at the same depth. For it, we can exploit the fact that fuzzy membership functions can be propagated from antecedents to consequents in the rules.
With all, if there are rules matching an input case (I), the following algorithm to acquire conclusions is proposed:
Conclusion Acquisition (CA) algorithm
L_{i} = f {List of ordered conclusions (according with their certainty) associated to C_{i} } do
if Card(C_{i}) > 1 then
group the conclusions in C_{i} into compatibility classes such that, for each compatibility class, the conclusion having the greatest depth in the MCRDR structure is selected as the "representative" one for the compatibility class under question; the representative conclusions C_{1}(concept_{i}.attribute_{i}), C_{2}(concept_{i}.attribute_{i}), .., C_{m}(concept_{i}.attribute_{i}) will be obtained;
classify the soobtained conclusions according to the depth of their location in the MCRDR structure in a decreasing order; the sets of representative conclusions C^{1}(concept_{i}.attribute_{i}),C^{2}(concept_{i}.attribute_{i}),.., C^{s}(concept_{i}.attribute_{i}) will be obtained;
for every C^{j}(concept_{i}.attribute_{i}) do
if Card(C^{j}(concept_{i}.attribute_{i})) > 1 then
group the conclusions in C^{j}(concept_{i}.attribute_{i}) into rule antecedentbased membership function values in a decreasing order; record each value together with the conclusion to which that value is associated;
L_{i} = L_{i} È C^{j}(concept_{i}.attribute_{i});
else L_{i} = L_{i} È C_{i}
where the compatible conclusions are obtained from the following definition:
Definition 17: compatible/incompatible conclusions
Let C_{1} and C_{2} be two conclusions involving the valued attributes VA_{1} and VA_{2}, respectively. C_{1} and C_{2} are said to be two compatible conclusions, written compatible_conclusions (C_{1}, C_{2}), if compatible_valued_attributes (VA_{1}, VA_{2}) holds. In an analogous way, they are said to be two incompatible conclusions, written incompatible_conclusions (C_{1}, C_{2}), if not(compatible_valued_attributes(VA_{1}, VA_{2})) holds.
Once the conclusions have been grouped, the following algorithm will be carried out in this approach:
Conclusion Show (CS) algorithm
For i=1 to n do {n = number of pairs (concept,attribute)}
for j=1 to m_{i} do { m_{i} = number of elements in L_{i}}
show L_{i}^{j} to the expert;
if he or she does not agree with L_{i}^{j} then
ask the expert to enter a new conclusion, NC, such that it will only affect the fired rule(s) containing L_{i}^{j} or another compatible conclusion(s) situated at the same depth in the MCRDR structure than L_{i}^{j};
if j < m_{i} then
for k = j + 1 to m_{i} do
if compatible_conclusions(NC, L_{i}^{k}) then
L_{i} = L_{i} \{ L_{i}^{k}}; m_{i} = m_{i}  1
Concerning the CA algorithm, we must clarify how to proceed with the propagation of membership function values from the antecedent to the consequent part of a fired rule. For it, there are several methods (Bárdossy, 1995), including the algebraic productsum, the Hamacher productsum, the Einstein productsum, and the Bounded differencesum. In this article, the algebraic product has been chosen, as it provides a good alternative and is computationally parsimonious. Through this method, the membership function value of the consequent of a rule is calculated as the product of the membership function values corresponding to the each of the sub conditions forming the antecedent of the rule under question. Therefore, the problem will be reduced to how to calculate the membership function value for each sub condition of the antecedent.
To calculate the membership function value (MFV) associated to a sub condition, it must be considered the fact that rules as well as input cases can include crisp or fuzzy valued attributes. In this sense, if a rule condition is crisp, an MFV equals to 1 will be assumed. Otherwise, the MFV will be dependent of the nature of the input case condition that matches the rule condition under question. For analysing the possible situations that can arise when the condition of the rule under question, written COND’, is a fuzzy valued attribute, we will attend to the nature (crisp or fuzzy) of the condition, written COND, in the input case.
In this situation, the MFV for COND’, written MFV(COND’), will be calculated as follows:
MFV(COND’) =
Where M_{inf} =
M_{sup} =
v_{inf} represents the inferior limit value of the attribute underlying COND;
v_{sup} represents the superior limit value of the attribute underlying COND;
T_{i}(v) represents the fuzzy membership function valued for v and associated to the ith element of the triple defining the attribute that underlies COND’; i = 1, 2, 3; v Î {v_{inf}, v_{sup}}
When the condition under question in the input case contains a fuzzy valued attribute, the method proposed here to calculate the membership function value of the rule condition that matches the input case condition can be written as follows:
MFV(COND’) =
where
C.A stands for the concept and the attribute, respectively, referenced in both COND and COND’;
M_{inf} and M_{sup} are according to the definition given in the previous subsection.
At this point, it is possible to obtain a membership function value for a conclusion in a certain rule by taking into account all the membership function values of the condition(s) in the antecedent of such a rule. For it, it can be noticed that three possible types of value for MFV have been considered, namely, numeric ones, intervalbased ones and those equals to "unknown". With all, by using the above assumptions and the notation employed before, a formula to propagate fuzzy values from antecedent to consequent parts in a rule is proposed in the following.
Let r be a rule in a FROCHbased system represented as ® C_{j}. Then, the membership function of the conclusion of r, written MFCO(r), is defined as follows:
MFCO(r) =
where
MFCO_{inf} (r) =
MFCO_{sup} (r) =
inf(MFV(C_{i}))= sup(MFV(C_{i}))=
In addition, if the expert disagrees with some conclusion and, according to step (S4.2) pointed out in Section 4, the system must decide where to add the new rules to be entered by the expert, each of them corresponding to a different wrong conclusion. The way to do that will be kept in FROCHbased systems, that is, the method used in MCRDR will be adopted. To be precise, given a wrong conclusion produced by the system, such a method adds the rule providing the right conclusion at the end of the path going to the rule that produced the wrong conclusion. With this, the system corrects the KB.
With MCRDR, various cornerstone cases may reach a new rule and the higher in the tree, the more cases can reach the rule. Moreover, every case that may reach its parent rule can potentially fire on the new rule. Therefore, the new rule should differentiate the input case from all the cornerstone cases except from those having their conclusion the same as that provided by the new rule. In other words, MCRDR possesses a number of cornerstone cases for a given rule, which must be prevented from satisfying the new rule.
With the purpose of making a new rule sufficiently precise, a very simple algorithm for selecting conditions is used in MCRDR. This algorithm reaches the goal of providing the new rule with sufficient precision so that it can uniquely be fired by the case it is being added for and no other cornerstone cases, provided that these do not involve a different conclusion. Given a new rule (corresponding to a wrong conclusion) to be added at a particular location, the mentioned algorithm works as follows (Kang, 1996):
With respect to the construction of a difference list between an input case and a cornerstone case, the features differentiating these cases must include at least a basis for a justification as to why the conclusions for the cases should differ. As it has been put forward in Section 2, the domain is supposed to be a closed world. Therefore, a negation of a condition belonging to the cornerstone case should be satisfied by the input case. Formally, given an input case, written I, and composed by n > 1 conditions, and a cornerstone case, written C, and composed by m > 1 conditions, the difference list, written D, can be defined as follows: D = D_{input} È D_{cornerstone}
Where: D_{input} = { I_{i}  (I_{i} Ï C)}; D_{cornerstone} = { NOT(C_{j}) (C_{j} Ï I)}; I = ; C = .
It can be noticed that, in general, C Ç I ¹ f .
In the particular case of FROCHbased systems, given the knowledge representation schema adopted in this article, the calculation of both D_{input} and D_{cornerstone} must be done according to the compatibility criteria (by assuming that there can be fuzzy valued attributes involved in such an schema) pointed out before. In the following lines, and by taking into account previous definitions, this issue is analysed in depth
Definition 18: Fnonmembership
Let A be a rule condition represented as follows:
A =
and let C be a case in a FROCHbased system to which A is confronted. A is said to be a nonmember of C in the mentioned context, written Fnonmember (A, C), if not($ C_{j} Î C s. t. compatible_valued_attributes (C_{j}, A)) where C = .
By taking into account last definition and the classic method to construct difference lists in RDRbased systems, a new definition for difference list in the context of FROCHbased systems can be expressed as follows:
Definition 19: Fdifference list
Let I and C be an input case and a cornerstone case composed respectively by n and m conditions; n, m ³ 1. The difference list between I and C in the context of a FROCHbased system, written Fdifference list (I, C), is defined as the union set FD_{input} È FD_{cornerstone}
Where FD_{input} = {I_{i}  Fnonmember(I_{i}, C)}; FD_{cornerstone} = {NOT(C_{j}) Fnonmember (C_{j}, I)};
I = ; C = .
Ripple down rules (RDR) is a knowledge acquisition technique whose aim is to use the knowledge only in the context provided by the expert, this context being the sequence of rules evaluated to give a certain conclusion. With this approach, rules are never removed or corrected, only added. This addition only occurs when the expert does not agree with a conclusion supplied by the system and, then, he or she wishes to correct such a conclusion.
Fuzzy terms are widely used in reallife problems to which current RDRbased systems may be applied. Although fuzzy logic is normally used to deal with fuzzy domains, those systems only allow to assign crisp values to fuzzybynature attributes. Moreover, current developments of RDR do not allow experts to use fuzzy terminology in a natural, compact manner. The knowledge that can be acquired and represented in such systems is, hence, restrictive and nonnatural from the experts’ point of view. In this paper, a formal approach that can be used to acquire and represent fuzzy domain knowledge through the most recent versions of RDRbased systems has been presented.
We have defined a model that allows experts to use fuzzy modifiers as well as fuzzy frequency quantifiers when they construct cases for a further processing by the system. Moreover, based on some welldefined assumptions about the kind of fuzzy terms that can be represented in our model, a new methodology for running cases, which can include both fuzzy and crisp values, has been proposed.
By considering the nature of RDR systems and some properties relative to fuzzy processing, two algorithms, concerning the acquisition of conclusions and their later presentation to the experts, have been designed. The most important factors considered in these algorithms are the rule base structure, the possibility of propagating fuzzy membership values from antecedents to consequents in rules and the model proposed here for running cases. With all, in this model, experts can be helped to make their choice when they are shown several conclusions alluding to the same feature. Finally, according to some wellestablished compatibility criteria among the conditions involving fuzzy valued attributes, a new method for identifying the conditions that must integrate a new rule to be added to the system has been put forward. Moreover, to illustrate the usefulness of the mathematical artefacts designed in this work, we have shown some examples that stem from a real problem involving environmental planning by assessment in Spain.
The approach presented is concerned with the acquisition/representation of fuzzy domain knowledge in RDRbased systems. Therefore, the formal model we have exposed can be viewed as an extension of current RDRbased systems to deal with fuzzy domains in a direct, natural way. In this sense, our approach is complementary to work on MCRDR systems (Kang, 1996) and the ROCH approach (MartínezBéjar et al., 1997b), as these provide methods to apply RDRbased systems to other more complex tasks and to construct RDR ontological frameworks, respectively.
Although the theoretical model proposed here is a first step forward in making fuzzy domain knowledge feasible and well founded, much work remains to be done. For instance, applying the logical negation to a fuzzy condition, represented as indicated in our model, in order to obtain the differences different cases can lead to experts’ difficulties in understanding the meaning of such a negation. Hence, the system should provide the experts with semantically equivalent sentences having a better degree of comprehensibility. Moreover, an implementation of the model proposed here is in course. In this sense, to evaluate the model through the feedback obtained from the experts’ working with an implementation of such a model is fundamental to know the real success of this approach.
References
Adlassnig, K.P., and Kolarz, G. (1982). CADIAG2: Computerassisted medical diagnosis using fuzzy subsets, In M. M. Gupta and E. Sanchez (Eds.), Approximate Reasoning in Decision Analysis, 219247, New York: NorthHolland.
Adlassnig, K.P., Kolarz, G., and Scheithauer, W. (1985). Present state of the medical expert system CADIAG2, Methods of Information in Medicine, 24, 1320.
Baldwin, J. F. (1992). Evidential support logic, frill and case based reasoning, International Journal of Intelligent Systems, 8(9), 939961.
Baldwin, J. F., and Pilsworth, B. W. (1980). Axiomatic approach to implication to approximate reasoning with fuzzy logic, Fuzzy Sets and Systems, 3: 193  219.
Bárdossy, A. (1995). Fuzzy RuleBased Modelling with Applications to Geophysical, Biological and Engineering Systems, CRC Press, Inc
Binaghi, E., De Giorgi, O., Maggi, G., Motta, T., and Rampini, A. (1993). Computerassisted diagnosis of postmenopausal osteoporosis using a fuzzy expert system shell, Computers and Biomedical Research, 26: 498516.
Buckley, J. J., Siler, W., and Tucker, D. (1986). A fuzzy expert system, Fuzzy Sets and Systems, 20: 1  16.
Catlett, J. (1992). Rippledownrules as a mediating representation in interactive induction, In Proceedings of the Second Japanese Knowledge Acquisition for KnowledgeBased Systems Workshop, 155170, Kobe, Japan.
Clancey, W. J. (1991). Book review of 'The Invention of Memory', Artificial Intelligence, 50(2): 241284.
Clancey, W. (1993). The frame of reference problem in the design of intelligent machines, In K. VanLehn and A. Newell (Eds.), Architectures for Intelligence: The twenty second Carnegie Symposium on Cognition, Hillsdale, Lawrence Erlbaum Associates.
Compton, P. (1992). Insight and knowledge, In AAAI Spring Symposium: Cognitive Aspects of Knowledge Acquisition, 5763, Stanford University.
Compton, P., Horn, R., Quinlan, R. and Lazarus, L. (1989). Maintaining an expert system, In J. R. Quinlan (Eds.), Applications of Expert Systems, 366385, London, Addison Wesley..
Compton, P. and Jansen, R. (1989). Knowledge in context: a strategy for expert system maintenance, In C. J. Barter and M. J. Brooks (Eds.), AI'88, 292306, Berlin, SpringerVerlag.
Compton, P. and Jansen, R. (1990). A philosophical basis for knowledge acquisition, Knowledge Acquisition, 2: 241257.
Compton, P. and Preston, P. (1990). A minimal context based knowledge acquisition system, in Knowledge Acquisition: Practical Tools and Techniques AAAI90 Workshop, Boston,
Compton, P., Preston, P., Kang, B. and Yip, T. (1994). Local patching produces compact knowledge bases, In L. Steels, G. Schreiber & W Van de Velde, A Future for Knowledge Acquisition: Proceedings of EKAW'94, 104117, Berlin, Springer Verlag.
Compton, P., Preston, P. and Kang, B. (1995). The use of simulated experts in evaluating knowledge acquisition, In B. Gaines & M. Musen, Proceedings of the 9th AAAISponsored Banff Knowledge Acquisition for KnowledgeBased Systems Workshop, 12.112.18, Banff, Canada, University of Calgary.
Daniels, J. E., Cayton, R. M., Chappell, M. J., and Tjahjadi, T. (1997). Cadosa: a fuzzy expert system for differential diagnosis of obstructive sleep apnoea and related conditions, Expert Systems with Applications, 12(7): 163177.
Dreyfus, H. and Dreyfus, S. (1988). Making a mind versus modelling the brain: artificial intelligence back at a branchpoint, Daedalus, 117(Winter): 1543.
Dubois, D., and Prade, H. (1988). Possibility Theory, an Approach to Computerised Processing of Uncertainty, New York, Plenum Press.
Edwards, G., Compton, P., Malor, R., Srinivasan, A., and Lazarus. (1993). PEIRS: a pathologist maintained expert system for the interpretation of chemical pathology reports, Pathology, 25: 2734.
FathiTorbaghan, M., and Meyer, D. (1994). MEDUSA: A fuzzy expert system for medical diagnosis of accute abdominal pain, Methods of Information in Medicine, 33: 522529.
Gaines, B. (1991). Induction and visualisation of rules with exceptions, 6th AAAI Knowledge Acquisition for Knowledge Based Systems Workshop, 7.17.17, Bannf.
Gaines, B. R. and Compton, P. J. (1992). Induction of ripple down rules, AI '92 Proceedings of the 5th Australian Joint Conference on Artificial Intelligence, 349354, Hobart, Tasmania, World Scientific, Singapore.
Gisolfi, A., and Di Lascio, L. (1995). POTCLAS: a fuzzy expert system for the classification of archaeological pottery fragments, International Journal of Expert Systems, 8(2):145164.
Grabot, B., and Caillaud, E. (1996). Imprecise knowledge in expert systems: a simple shell, Expert Systems with Applications, 10(1): 99112.
Grabot, B., Geneste, L., and Dupeaux, A. (1994). Multiheuristic scheduling: three approaches to tune compromises, Journal of Intelligent Manufacturing, 5: 303313.
Horn, K., Compton, P. J., Lazarus, L. and Quinlan, J. R. (1985). An expert system for the interpretation of thyroid assays in a clinical laboratory, Aust Comput J 17 : 711 .
Hwang, GJ. (1995). Knowledge acquisition for fuzzy expert systems, International Journal of Intelligent Systems, 10:541560.
Kandel, A. (1990). Fuzzy mathematical techniques with applications, Reading, MA, AddisonWesley.
Kang, B. H. (1996). Validating Knowledge Acquisition: Multiple Classification Ripple Down Rules, PhD Thesis, University of New South Wales, Sydney, Australia.
Kang, B. and Compton , P. (1992). Knowledge acquisition in context: the multiple classification problem, In Proceedings of the Pacific Rim International Conference on Artificial Intelligence, 847854, Seoul.
Kang, B. H., Compton, P., and Preston, P. (1995). Multiple classification ripple down rules: evaluation and possibilities, In Proceedings of the 9th Knowledge Acquisition for Knowledge Based Systems Workshop, 17.117.20, SRDG Publications, Department of Computer Science, University of Calgary, Calgary, Alberta, Canada.
MartínezBéjar, R., Cádenas, J. M., and MartínRubio, F.(1997a). Fuzzy logic in landscape assessment, In Proceedings of the European Symposium on Intelligent Techniques, 234238, Bari, Italy.
MartínezBéjar, R., Benjamins, V. R., Compton, P., Preston, P., and MartínRubio, F.,. (1997b). A formal framework to build domain knowledge ontologies for ripple down rulesbased systems, In Press.
Richards, D., and Compton, P. (1997a). Combining formal concept analysis and ripple down rules to support the reuse of knowledge, in Proceedings of the 9th International Conference of Software Engineering and Knowledge Engineering SEKE’97, Madrid, Spain.
Richards, D., and Compton, P. (1997b). Knowledge acquisition first, modelling later, To appear in Lectures Notes in Artificial Intelligence, SpringerVerlag, Berlin.
Scheffer, T. (1996). Algebraic foundation and improved methods of induction of ripple down rules, In Proceedings of Pacific Knowledge Acquisition Workshop PKAW’96, 279292, Coogee, Australia.
Srinivasan, A., Compton, P., Malor, R., Edwards, G. and Lazarus, L. (1992). Knowledge acquisition in context for a complex domain, In B. Wielinga, J. Boose and B. Gaines (Eds.), Proceedings of the Fifth European Knowledge Acquisition Workshop, Pergamon.
Sugeno, M. (1985). An introduction survey to fuzzy control, Information Sciences, 36: 149223.
Watanabe, T. (1991). Jobshop scheduling using fuzzy logic in a computer integrated manufacturing environment, In G. Lasker, T. Koizumi and J. Pohl (Eds.), 5^{th} International Conference on Systems Research, Informatics and Cybernetics, 150158.
Winograd, T. and Flores, F. (1987). Understanding computers and cognition, Reading, MA, Addison Wesley.
Yager, R. R. (1984). Approximate reasoning as a basis for rulebased expert systems, IEEE Transactions on Systems, Man, and Cybernetics, 14: 636  643.
Zadeh, L. A. (1965). Fuzzy sets, Information and Control, 8: 338353.
Zadeh, L. A. (1983). The role of fuzzy logic in the management of uncertainty in expert systems, Fuzzy Sets and Systems, 8(3): 199  227.