1 Spanish Scientific Research Council, Avda. La Fama, 1, C. P. 30080- Murcia, Spain. E-mail: rodrigo@pandora.dif.um.es

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 RDR-based 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 RDR-based approach developed recently is the so-called Ripple down rule-Oriented Conceptual Hierarchy (ROCH) (Martínez-Béjar et al., 1997b). The basic idea concerning ROCH-based 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 ROCH-based 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 to-date. 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 ROCH-based 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 GARVAN-ES1 (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 "if-not" (false) rules. By using this approach, the exception rules are evaluated once a rule is satisfied. If so, none of the if-not 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 MCRDR-based system as in a simple RDR-based 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 n-array 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 rule-Oriented Conceptual Hierarchy (ROCH)-based system (Martínez-Béjar et al., 1997b), that allows experts to construct and validate domain knowledge ontology while they enter knowledge to the KB for RDR-based systems. In essence, in ROCH-based 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 IS-A and PART-OF 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ínez-Bé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₁, r₂}. 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):

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 IS-A 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 step-by-step process the exclusive, restrictive model of knowledge acquisition/representation contemplated in ROCH-based 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 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 so-called 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.

According to Buckley et al. (1986), a fuzzy expert system (FES) must hold the following :

• it must contain a set of rules that can deal with fuzzy tags, fuzzy sets and relations;
• it becomes feasible to process the data in a particular knowledge base (KB);
• it must provide an appropriate output, which corresponds to a particular input.

More formally, every FES can be characterised by the following:

1. it can manipulate fuzzy terms;
2. its input is comprised of imprecise attributes, which can be represented by either discrete fuzzy sets or continuous fuzzy sets.
3. its rules are defined so that they can operate with fuzzy data.
4. the final result is a fuzzy set.

A number of FESs have been successfully implemented to-date. Examples of these can be found in Adlassnig et al. (1985), Binaghi et al. (1993), Fathi-Torbaghan and Meyer (1994), Gisolfi and Di Lascio (1995), Hwang (1995), Daniels et al (1997) and Martínez-Bé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:

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 so-called TFM function (Kandel, 1990) has demonstrated to be useful (see, for example, Gisolfi and Di-Lascio (1995)). This function works as follows:

A practical example of the use of that function is the one pointed out in Martínez-Béjar et al. (1997a). In this case, we have modelled the vague predicates containing modifiers by using the next TFM function:

where

Although, as it has been pointed out already, in this paper ROCH-based systems are used instead of classical RDR, problems still remain if one wants to apply the RDR philosophy to fuzzy domains. Firstly, ROCH-based 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:

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:

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₁: If (vegetation.diversity < 10) then (landscape.visual_quality < 5%);

R₂: 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; Lopez-De Mantaras, 1990; Gisolfi and Di-Lascio, 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 expert-driven policy for modelling fuzzy modifiers and fuzzy frequency quantifiers.

With all, a model, which can be used not only for ROCH-based systems, to manipulate fuzzy modifiers and fuzzy frequency quantifiers is formally formulated in the following lines.

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:

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.

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₁, h₂, h₃,..};

LOW_ FREQUENCIES = L = {"almost never", "very seldom", "seldom",..}= {l₁, l₂, l₃,..};

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 .

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 ROCH-based 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.

(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)

Let R be a ROCH-based system. R is said to be a fuzzy ripple down rules-oriented conceptual hierarchies (FROCH)-based system, written FROCH-based 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:

14. VA =

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;

With RDR-based 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 problem-solving method in FROCH-based 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 FROCH-based systems, the KA process will consist of performing the following steps:

Regarding the steps to be followed in the KA process in a FROCH-based 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 FROCH-based 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 FROCH-based 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.

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 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 by-default 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).

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 FROCH-based 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.

Formally, the referred criterion can be stated in a step-by-step 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.

Let < T₁, T₂, T₃> 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₁ and V₂ be two elements belonging to the union set . V₁ and V₂ are said to be two compatible fuzzy values, written compatible_values (V₁, V₂), if the following holds:

Otherwise, that is, if the above condition does not hold, p₁ and p₂ are said to be two incompatible fuzzy values, written incompatible_values (V₁, V₂).

By applying the above lemma to the characteristics of the fuzzy memberships functions underlying a FROCH-based system, the following definitions can be written.

Let p be a parameter defining a fuzzy membership function associated to a fuzzy valued attribute, written FVA, in a FROCH-based system; and let MPCD be the maximum parameter-based compatibility distance for FVA. The parameter-based compatibility range for p, written PCR(p), is defined as the interval [p - MPCD, p + MPCD].

Firstly, we can extend the maximum parameter-based compatibility distance concept to the case of two (in general) different fuzzy attributes. For it, we will take into account the following principle.

Secondly, by considering what definition 2 states, we can restrict the parameters that could potentially be semantically inter-compatible to those whose values belong to the same class.

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 step-by-step 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 so-obtained 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:

Figure 2. Accumulation of parameters.

Formally, this situation can be expressed in the following principle:

where

Based on the three principles exposed before, the following definition can be derived:

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

The above principle can be used to formally define the compatibility it alludes to as follows:

where

Otherwise, that is, if the above logic equation does not hold, q₁ and q₂ are said to be two incompatible fuzzy frequency quantifiers, written incompatible_quantifiers(q₁, q₂).

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.

M₁=; M₂=;

M₃=; M₄ = ;

Otherwise, that is, if the above logic equation does not hold, q₁ and q₂ are said to be two incompatible fuzzy modifiers, written conflicitve_modifiers(q₁, q₂).

By considering the previous definitions, a compatibility/conflictivity criterion to be applied to eventually fuzzy valued attributes in the context of a FROCH-based system can be derived as follows.

EQUAL₁₂ = (FVA₁ = FVA₂);

EQUAL_ca (FVA₁, FVA₂) = (c₁.a₁ = c₂.a₂); and

Similarly, the following definition can be established:

When a case is entered to a FROCH-based 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 string-based one and the numeric interval-based one. All these possibilities are analysed in the following lines.

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:

Let FVA ₁ and CSVA ₂ be a fuzzy valued attribute and a character string-like valued attribute in a FROCH-based system and represented, respectively, as follows :

FVA ₁ and CSVA ₂ are said to be s-compatible, written s-compatible(FVA ₁, CSVA ₂), if (concept₁.attribute₁ = concept₂.attribute₂) and (compatible_values(v₁, v₂)) and (compatible_modifiers(m₁, m₂)) and (compatible_quantifiers(q₁, q₂)) holds.

active_interval (C.A, FVA) =

where

Now, the following definition can be established:

Let FVA ₁ and NIVA ₂ be a fuzzy valued attribute and a numeric interval-like valued attribute in a FROCH-based system and represented, respectively, as follows :

where

By using previous definitions, the condition for a given rule in a FROCH-based system to by fired by an input case, can be established as follows:

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 FROCH-based system) as follows:

C_k =

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 FROCH-based 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, inter-compatible 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:

1. A set of conclusions (C) corresponding to the consequents of the rules that match I is generated;
1. the system classifies the conclusions in C according to their pair (concept,attribute) referenced in each of them. The sets C₁, C₂, .., C_n will be obtained;
1. for every C_i do { C_i = (concept _i.attribute _i)

Let C₁ and C₂ be two conclusions involving the valued attributes VA₁ and VA₂, respectively. C₁ and C₂ are said to be two compatible conclusions, written compatible_conclusions (C₁, C₂), if compatible_valued_attributes (VA₁, VA₂) holds. In an analogous way, they are said to be two incompatible conclusions, written incompatible_conclusions (C₁, C₂), if not(compatible_valued_attributes(VA₁, VA₂)) holds.

Once the conclusions have been grouped, the following algorithm will be carried out in this approach:

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 product-sum, the Hamacher product-sum, the Einstein product-sum, and the Bounded difference-sum. 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;

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 sub-section.

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, interval-based 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.

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 FROCH-based 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):

• A cornerstone case list containing the cases that can reach the new rule is created.
• Since the input case should be distinguished from these cases, a similar policy to that used for classic RDR systems has been followed in MCRDR. Thus, the expert is shown a difference list between the input case and one of the elements of the mentioned list of cornerstone cases. In this manner, he or she can select as many conditions as necessary to justify the new conclusion according to his or her criterion.
• The system tests all cornerstone cases in the list against the conditions selected in order to delete from this list the cases that do not satisfy these conditions.
• The expert selects conditions from another difference list between one of the rest of the elements in the list of cornerstone cases and the input case.
• The so-selected conditions are appended to the rule (as a conjunction).
• The system repeats this process until the list does not contain any cornerstone case satisfying the rule.
• The system adds the rule with the selected conditions to the rule base.
• The system tests the cornerstone cases associated to rules having the same conclusion as the new rule.
• Each of these cases that can also satisfy the new rule are flagged as a cornerstone case of the new rule.
• The system adds the input case to the cornerstone cases database.
• The lists of cornerstone cases corresponding to other rules giving a correct conclusion for the input case are also updated in order to include the input case.

In the particular case of FROCH-based 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

Let A be a rule condition represented as follows:

A =

By taking into account last definition and the classic method to construct difference lists in RDR-based systems, a new definition for difference list in the context of FROCH-based systems can be expressed as follows:

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 real-life problems to which current RDR-based systems may be applied. Although fuzzy logic is normally used to deal with fuzzy domains, those systems only allow to assign crisp values to fuzzy-by-nature 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 non-natural 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 RDR-based 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 well-defined 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 well-established 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 RDR-based systems. Therefore, the formal model we have exposed can be viewed as an extension of current RDR-based 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ínez-Béjar et al., 1997b), as these provide methods to apply RDR-based 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.