P1: VTL/EHE

Applied Intelligence KL450-01-Dubitzky May 13, 1997 15:35

Applied Intelligence 7, 187–204 (1997)

°
c 1997 Kluwer Academic Publishers. Manufactured in The Netherlands.

An Advanced Case-Knowledge Architecture Based on Fuzzy Objects

WERNER DUBITZKY, ALFONS SCHUSTER, JOHN HUGHES AND DAVID BELL

School of Information and Software Engineering, University of Ulster, Jordanstown, Ireland
w.dubitzky@ulst.ac.uk

Abstract. The case-based reasoning (CBR) architecture described in this paper represents a substantive ad-
vancement in the representation of case-knowledge. It addresses three major problems found in current CBR
schemes: 1) Insufficient treatment of abstract case features’ context-dependent characteristics. 2) Lack of a me-
thodical support for atomic and structured case features that contain and represent imprecisely specified quantities.
3) And little account for clustering and organising cognate cases into conceptually overlapping categories. To
overcome the representational inadequacy resulting from those deficiencies, this work proposes two modelling
fundamentals, namely, fuzzy primitive and fuzzy complex abstract features. These allow a flexible, polymorphic
encoding of case characteristics as real numbers, linguistic terms, fuzzy numbers and fuzzy complex objects
respectively. Based on this concept, it is possible to systematically organise a case base in fuzzy categories,
reflecting real-world case clusters. In the presented scheme, a prototype case and its associated approximation
scales form the basis to realise a versatile mechanism to represent the context-specific idiosyncrasies of fuzzy
abstract case features. Case categories, fuzzy abstract features, cases, and the approximation scale concept are
modelled as self-contained, operational entities. They co-operatively concert their services when they categorise
an unclassified problem description (target case), and locate relevant stored cases. Applied to the Coronary Heart
Disease risk assessment domain, the proposed architecture has proven to be highly adequate for capturing and
efficiently processing case-knowledge. Moreover, as this scheme is designed upon well-established object-oriented
principles, it has been shown that it can seamlessly integrate in a wider, more general knowledge management
regime.

Keywords: case-based reasoning, knowledge representation, fuzzy logic, soft computing, object-orientation

1. Introduction those systems are usually of frame-based or table-

CBR is a problem solving style that revolves around
the organisation of past cases in a memory called case
base. A prerequisite for problem solving from cases is
the capability to retrieve relevant past cases applicable
to the new situation. Many case-knowledge schemes
and architectures have been proposed in the litera-
ture, two of the more promising ones are based on
exemplar-based (EBR) and memory-based reasoning
(MBR). The former type of system revolves around
the classification of unclassified cases, whereas the
latter focuses on case organisation in a memory-like
structure. However, the modelling fundamentals in
structured nature. When more complex, so-called “real-
world”, information and knowledge concepts are to be
expressed, the limitations of those schemes come to
light [2, 5, 20]. To avoid the problems associated with
those representation languages, the C41 architecture
is designed around powerful, object-orientated ab-
straction and modelling mechanisms such as class,
object, inheritance, aggregation, polymorphism, etc.
In fact, several C4 components could only be re-
alised, in a meaningful way, through the deployment
of the dynamic and static binding facilities provided
by object-oriented (OO) modelling and programming
techniques.
P1: VTL/EHE
Applied Intelligence KL450-01-Dubitzky May 13, 1997 15:35
188 Dubitzky et al.
Another problem found in “traditional” case-
knowledge representation schemes is the lack of
support for context; case attributes or features are
usually treated in a rigid, uniform manner. For most
but the simplest applications this treatment of case
characteristics is not satisfactory [10, 12]. In the C4
approach, a prototypical case is stored with each case
category. Amongst other things, such a prototype serves
to express the context-specific properties a case feature
type may assume in the “surroundings” of a particular
category.
Finally, when specifying a query case or a stored
base case, it is often the case that constituent val-
ues can not be articulated precisely. This uncertainty
may be caused by partial ignorance, unquantifiable or
incomplete-information. Such situations are the rule,
rather than the exception, and humans resort to fuzzily
quantified specifications to cope with this sort of prob-
lem [10, 15, 26, 29]. The C4 approach proposes a
systematic method to represent and use fuzzy case fea-
tures in a context-sensitive fashion. Based on fuzzy
complex and fuzzy primitive abstract features, cases
can be organised in conceptually overlapping cate-
gories, stored and retrieved via a classification and
similarity regime that methodically combines feature
values encoded in mixed fuzzy and crisp format. This
concept significantly contributes to the flexibility and
expressiveness with which case-knowledge can be
represented.
As the above-mentioned concepts greatly add to the
representational adequacy and epistemological sound-
ness of case-knowledge representation strategies, the
C4 architecture is considered as “advanced”. More-
over, on the grounds of strict compliance with OO prin-
ciples and ODMG’s [8] object model, it has been shown
that the C4 scheme can serve as a basis for advanced
knowledge management [14].
The C4 scheme is realised as a prototype C++ imple-
mentation applied to the Coronary Heart Disease risk
assessment domain.
The remainder of the paper is organised as follows:
Section 2 gives an overview of the presented fuzzy
case-knowledge representation scheme. Sections 2.1
through to 2.2.4 demonstrate and define the no-
tion of fuzzy primitive abstract features along with
their constituent components (e.g., approximation
scales, p-functions, etc). In the light of the Coro-
nary Heart Disease Risk Assessment domain Sec-
tions 2.3 to 2.3.3 discuss and define the concept
of fuzzy complex abstract features. And Section 3
finishes with some conclusions and an outlook to future
work.
2. The C4 Case-Knowledge Architecture
The following gives a concise overview of the over-
all C4 case-knowledge architecture so as to provide a
suitable context for the understanding of the fuzzy ab-
stract case feature concept proposed in this paper. For
a more comprehensive description of the C4 compo-
nents that are not considered here in great detail refer
to [14].
The C4 case-knowledge architecture realises a case
memory organisation and classification system that
groups conceptually cognate, self-contained case en-
tities into fuzzy categories. A category represents the
attribute-based intention or concept of the cases it or-
ganises. As cases are clustered into categories in accor-
dance with their membership degree—rather than in a
binary “yes-or-no” fashion—the concept boundaries of
a category are said to be fuzzy. In fact, a single case may
be an instance of more than just one category, as long
as its membership degree, in the according category,
is above some pre-specified threshold. The fuzzy con-
cept formation scheme, realised in the C4 architecture,
is based on fuzzy abstract case features. Fuzzy abstract
features form the fundamental basic case-knowledge
modelling primitives in a C4 system.
To address representational adequacy as well as gen-
erality and performance issues, the C4 case-knowledge
representation scheme is based on a combination of the
EBR and MBR approaches [2]. The former type of sys-
tem revolves around the classification of unclassified
cases, whereas the latter focuses on a memory-like case
organisation architecture. The breakdown of a C4 case
base is orthogonal: Contexts and categories represent
the case base’s conceptual and organisational structure
(memorising, reminding), and category instances re-
flect the actual cases themselves.
Contexts and categories are deployed to bundle to-
gether related knowledge items at different levels of ab-
straction and granularity. Forming a navigational struc-
ture, contexts and categories also embody operational
CBR services that are used to locate relevant case clus-
ters, and to identify the most relevant case within a
category. One important operation, for example, is that
to determine the category membership of an unclas-
sified target case. The context/category network of a
C4 case base is realised as a rooted, acyclic, directed
P1: VTL/EHE
Applied Intelligence KL450-01-Dubitzky May 13, 1997 15:35
graph G. This structure constitutes a pre-compiled,
knowledge-driven substitute of the more conventional
symbolic indexing schemes that have been proposed
in CBR literature [4, 6, 18]. Each terminal node in
that graph represents a case category Ci , non-terminal
nodes (except for the graph’s root node) describe a con-
text K j . Thus, via the has-sub-component relationship
between two nodes a and b (a has-sub-component b
is denoted by “a → b”), a category c ∈ Ci can be
reached by a path of the form: root → k1 → k2 →
· · · → kn → c (where kk ∈ K j and 1 ≤ k ≤ n).
Apart from serving as connecting nodes in the navi-
gational graph scaffolding, contexts and categories rep-
resent information so as to actively carry out tasks such
as feature extraction and feature matching. A context
node, unlike a category, does not directly reference any
cases. Rather, a context K j represents feature type in-
formation that make up part of the intentional descrip-
tions of all the categories Ck organised below K j in
the hierarchy G (Ck ⊂ Ci ). This organisation makes it
possible to avoid irrelevant branches when a new target
case is considered (classified) for storage or retrieval.
So a context K j can be thought of as an abstract cat-
egory, for it subsumes the common characteristics of
categories that can be reached by a has-sub-component
traversal path rooted at K j .
The category nodes Ci , on the other hand, are spe-
cialised context components, since they also manage an
actual set of stored base cases E i (the extension of the
concept represented by the category Ci ) and a single
prototype case pi . The prototype case pi constitutes
a norm or a prototypical member of Ci . The classi-
fication procedure compares the target case t against
pi when it establishes t’s membership degree in the
category Ci . The category-specific feature definitions
represented in pi are also used by the similarity assess-
ment process for determining the conceptual similarity
between a classified target case t and a base case bi j
stored in the category Ci (bi j ∈ E i ). As the relation-
ships between the stored base cases, their constituent
abstract features and the prototype case are crucial for
the understanding of the following discussion, they are
depicted in the diagram below.
Figure 1 illustrates an example of a simple category
containing two base cases b1 and b2 , and a prototype
case p. In the diagram, the cases are depicted by small
round boxes, and the cases’ constituent features are
drawn as circles (the solid lines between circles re-
flect the features’ hierarchical composition). The cases
are formed from the complex feature type f 2 (with
An Advanced Case-Knowledge Architecture 189
Figure 1. A category node and its constituent member cases.
the atomic constituents f 21 , f 22 ), and the atomic fea-
ture type f 1 . The instantiation of, for instance, case
b1 is given by: b1 := < 3.12, <"X", 181> >.
There exists a 1-to-M association relationship between
the feature instances in the prototype p and the cor-
responding base case feature instances (dotted line).
For example: (f1 := <3.50>) 1-to-2 { (f1 :=
<3.12>), (f1 := <4.20>) } between p’s and
the base cases’ f 1 instances. Note, complex as well
as atomic feature instances carry a unique object iden-
tifier (only those of complex features are shown in the
diagram, e.g., id03 , id06 ).
Henceforth, the terms context and category are of-
ten used interchangeably, as both establish a contex-
tual frame within which abstract features are to be
interpreted.
2.1. Pre-Defined Features
Usually, a finite universal set F of pre-defined domain-
specific features constitutes the frame of discernment
within which a case-based reasoner operates. A subset
A of F is used to represent salient or abstract features,
A ⊂ F. Abstract features played a fundamental role
when a past case was evaluated and its outcome or
solution was determined. Highly interwoven with the
abstract feature notion are the concepts of a context (or
category) and similarity; both notions are central to all
forms of analogical reasoning, hence for CBR [16, 26].
The sophisticated classification and similarity
regime presented in this work is based on the rep-
resentation of fuzzy abstract features. It is differen-
tiated between complex, that is structured, abstract
features and primitive abstract features. Complex ab-
stract features are recursively defined, via nested set
and record formation, in terms of primitive abstract
features. Examples, within a dating agency scenario,
P1: VTL/EHE
Applied Intelligence KL450-01-Dubitzky May 13, 1997 15:35
190 Dubitzky et al.
for primitive abstract features include Age, Height,
Figure, and possible instances thereof are <22>
(years), <180> (cm) and <60> (cm waist circumfer-
ence). An example for a complex abstract feature is
Body, where Body may be described by the feature ag-
gregate [ Height, Figure ]. A particular Body
instance b may be given by b := <180, 60>. Note,
that the above feature quantities are defined in crisp
format.
Frequently, however, humans can not obtain or as-
sess a value for a feature precisely. This uncertainty
may come from sources such as partial ignorance, un-
quantifiable, incomplete or non-obtainable informa-
tion [9]. For example, a suspect s might be described
by a witness by s := <"TALL", "SLIM">. To cap-
ture the imprecision of human behaviour and to take
into account human subjectivity, it is proposed to ex-
tend the abstract case feature notion by introducing
fuzzy abstract features. Fuzzy abstract features should
increase the flexibility and naturalness with which CBR
concepts can be expressed.
In the C4 scheme, there are two types of fuzzy ab-
stract features: fuzzy complex abstract feature and fuzzy
primitive abstract feature. Fuzzy complex abstract fea-
tures are defined recursively in terms of fuzzy primitive
abstract features.
To allow for a flexible mixed format encoding of case
features, fuzzy primitive abstract features are modelled
by means of the following concepts: crisp number, lin-
guistic term and fuzzy number. A crisp number con-
stitutes a real number. Humans employ both linguistic
terms and fuzzy numbers to express uncertainty. Lin-
guistic terms are formed from natural language words
and expressions (e.g., very, poor, more or less accept-
able, etc.). Whereas fuzzy numbers are constructed
by means of an inexact proximity quantifier and a cor-
responding crisp number. A Comfortable-Room-
Temperature feature instance t, for example, could
be specified by t := <"AROUND", 21> (around 21
degrees Celsius). The proposed fuzzy primitive ab-
stract feature data type is polymorphic since it can as-
sume fuzzy as well as crisp instance values. To briefly
illustrate this, consider the fuzzy primitive abstract fea-
ture Height again. In order to instantiate the Height
feature, the overloaded Create message is sent to the
class Height [8, 11]2 :
crisp := < Create(179) --
--> Height >
lt := < Create("TALL") --
--> Height >
fn := < Create("ROUGHLY",180)
--
--> Height >
The first expression constructs the Height instance
<179> and binds it to the instance variable crisp.
The second and third result in the bindings lt :=
<TALL> (representing the linguistic term tall), and fn
:= <"ROUGHLY", 180> (the fuzzy number roughly
180 cm).
The above-introduced notion can be extended to
fuzzy complex abstract features. This means that a
fuzzy complex abstract feature can assume a crisp
value, a holistic linguistic term, and a holistic fuzzy
value.
To illustrate this, a simple example from a fictitious
dating agency case base is presented below. Two fuzzy
complex abstract feature classes are defined as follows
(the notation “C ::= [{S}, {M}]” is used to denote the
definition of an object class C in terms of its structural
S and operational M properties):
Body ::= [ { Height: FPAF; Figure: FPAF
feature }, { (* methods *) } ].
Idol ::= [ { Age: FPAF; body: Body },
{ (* methods *) } ].
Note, the class Body is defined in terms of two fuzzy
primitive abstract features, namely Height and Fig-
ure; both are of system-supplied type FPAF. The class
Idol is composed of a primitive and a complex fea-
ture, Age and Body respectively. Not indicated in the
definition is the fact that both complex classes, Body
as well as Idol, are derived from the generic, system-
defined fuzzy complex abstract feature class FCAF (see
later sections).
The following specifications instantiate the two
fuzzy complex abstract feature classes Body and Idol:
b0 := < Create( ("ROUGHLY", 160),
"VERY SLIM" ) ----> Body >
mary := < Create( 35, (b0) ) --
--> Idol >
jane := < Create( "LIKE", (mary) ) --
--> Idol >
peter := < Create( "VERY ATTRACTIVE" )
--
--> Idol >
b1 := < Create( 184, "SLIM" ) --
--> Body >
paul := < Create( "OLD", (b1) ) --
--> Idol >
The expressions yield the fuzzy complex abstract
feature instances that are bound to the object variables
mary, jane, peter and paul respectively:
mary := < 35, < <"ROUGHLY",160>,
"VERY SLIM" > >, jane := <"LIKE",
(mary) >, peter := < "VERY
P1: VTL/EHE
Applied Intelligence KL450-01-Dubitzky May 13, 1997 15:35
ATTRACTIVE" >, and paul := <"OLD",
<184,"SLIM"> >.
Note, the expression (mary), in the jane instance,
reflects the situation that the complex instance mary
(see above) is embedded in the object jane. It is also
to be noted that none of the four complex objects above
is formulated entirely in crisp format.
Considering the instances mary, jane, peter and
paul again, the following important observations can
be made:
First, fuzzy complex abstract features have the po-
tential to express the fundamental Fuzzy Logic idea
“introduce imprecision to reduce complexity”. The in-
stance jane, for example, is an inexact specification
of an Idol instance, which, if it was to be defined pre-
cisely, requires the specification of two properties (one
of which is of complex nature).
Second, an observer has subjectively aggregated or
summarised peter’s feature values (Age and Body)
into the holistic fuzzy term very attractive. This im-
plies that the observer possesses some sort of Idol
“scale” that categorises Idol instances into fuzzy sub-
sets called, for example, unattractive, attractive and
very attractive respectively. This mechanism may vary
from observer to observer; another observer might have
classified peter as, for example, boring-looking.
Third, one of the most critical tasks in a CBR sys-
tem is to find cases that are conceptually close to—or
alike—a new problem case. Given the fact that cases
are usually perceived as entities exhibiting a high de-
gree of complexity [2], the expression < "LIKE",
(mary) > is at the heart of CBR, as it is concerned
with complex objects inside some conceptual neigh-
bourhood radius of < mary >.
The second point above relates to Cheng’s [10] criti-
cism, that in most existing works, a fixed, global feature
weighting (and prototypicality3 ) scheme is imposed on
the pre-defined features, invariant with respect to the
context or category a case, represented by those fea-
tures. For many case bases this approach constitutes
an oversimplification.
As C4’s fuzzy abstract features constitute aggregates
of crisp and fuzzy data, a special mathematical treat-
ment is necessary to establish combined scores so as to
compare and rank cases.
2.2. Fuzzy Primitive Abstract Features
An actual C4 system is eventually defined in terms
of pre-defined primitive abstract features. Before the
An Advanced Case-Knowledge Architecture 191
Figure 2. Fuzzy sets and membership functions.
structure and functionality of a fuzzy primitive abstract
feature can be defined, a brief look at some Fuzzy Logic
fundamentals is in order [19, 29].
A fuzzy set A is a set of objects drawn from the uni-
versal set U . Each object x(x | x ∈ A) is assigned a
membership degree that reflects the grade to which x
fits the concept represented by the set A. Formally,
A = {(x/µ(x) A ), x ∈ U }, (1)
where µ(x) A is called membership function; it is de-
fined as follows:
µ(x) A : U → [0, 1] (2)
Figure 2 illustrates above definitions. The diagram
shows an approximation scale involving three fuzzy
sets A, B and C. These sets take their elements from
the universal set Money (which represents a person’s
yearly income in units of some currency). The fuzzy
subset A, for instance, is represented via the member-
ship function µ(Money)poor (depicted by the solid-lined
graph in the diagram). Also illustrated in the diagram
is the membership degree (0.53) of an annual income of
10,000 units; in the fuzzy set A : µ(10000)poor = 0.53.
A linguistic term is a natural language expression
that imprecisely quantifies an attribute such as In-
come, Age, Safety, etc. Linguistic terms of this kind
can be seen as labels for fuzzy sets. Thus, the labels
poor, well-off, and rich, in the above example, refer to
the fuzzy sets A, B, C, and the corresponding state of
affairs.
A fuzzy number is used to handle inexactly specified
quantities, it is usually formulated by a linguistic ex-
pression reflecting closeness, and a real number N (e.g.,
around 35,000, more or less 50,000). Fuzzy numbers
are equivalent to fuzzy sets, they are therefore defined
by the Eqs. (1) and (2). The membership function de-
notes the degree of truth that N takes a specific number
P1: VTL/EHE
Applied Intelligence KL450-01-Dubitzky May 13, 1997 15:35
192 Dubitzky et al.
x (x ∈ U ). Consider, for example, the following state-
ment (see also Fig. 2): “The income of 10,000 units
per year is equivalent to that of roughly 5,000”. Ac-
cording to the relevant fuzzy number in the diagram,
this statement is true to a degree of 0.53.
2.2.1. C4’s Approximation Scales. The approximation
scale concept deployed in the C4 architecture encom-
passes more than the components described in Fig. 2.
The list below summarises the major functions of the
C4 approximation scale notion, a more formal defini-
tion is found in Section 2.2.4.
1. They realise the fuzzy subsets for a particular fuzzy
primitive abstract feature (see Fig. 2). This means
that they represent a set of membership functions,
a set of linguistic terms, and a set of (normalised)
fuzzy numbers. In C4, a normalised fuzzy number is
specified through the proximity term approximately
and a real number.
2. Approximation scales are represented as self-
contained entities that encapsulate the rules required
to process the similarity and prototypicality of cases.
These rules are also responsible for the transfor-
mation between feature values given in real num-
ber, fuzzy number, linguistic term and crisp score
format respectively (see below). For example, the
fuzzy number more or less 50,000, in the example
above, can be transformed into the linguistic term
rich.
3. One function, out of the set M of membership
functions represented by an approximation scale, is
called p-function. A p-function is used to establish
the prototypicality of a compatible feature value.
To support this service, the C4 approximation scale
class defines the method prototypicality.
4. In order to realise a context-specific evaluation (i.e.,
similarity and prototypicality degree, and relevance
weight) of instances of a particular abstract feature
type (e.g., Money), a dedicated approximation scale
can be associated with a feature type for each con-
text or category. This is accomplished via a pro-
totype case stored in each case category of a case
base. Apart from contributing to the representational
adequacy with which case-knowledge can be ex-
pressed, this approach has two other advantages.
First, it is extremely flexible, for the approximation
scales can be allocated dynamically, this means that
a case base can evolve gracefully since the before-
mentioned regimes are not compiled into the over-
all program. Second, for each combination of a
feature type F and a category C, where instances of
F occur, there exists only one approximation scale
(anchored at the prototype case), so that the scale
does not have to be maintained by every single case
stored in an individual category.
2.2.2. Prototypicality and P-Functions. When retriev-
ing cases the C4 inference cycle relies on the notion of a
membership degree m i in order to classify a target case
t as being a member of a category Ci . A target case’s
membership degree m i in Ci is established on the basis
of the target case’s constituent features’ membership or
prototypicality degrees P. The prototypicality degree
p j ∈ P is derived from a single membership function,
the p-function, represented in the approximation scale
of each primitive feature f j in a category’s prototype
case. For a given category Ci , the p-function of a fea-
ture f j reflects the possibilistic uncertainty associated
with the concept f j [21]. So for a crisp or fuzzy fea-
ture value x, f j ’s p-function is consulted to determine
to which extent p j the value x constitutes the concept
f j . To calculate the overall membership degree m i the
various prototypicality degrees P have to aggregated
taking into account their importance weights w j . With
a simple example from an imaginary dating agency case
base, it is now demonstrated how approximation scales
are deployed to establish a primitive abstract feature’s
membership or prototypicality degree p j . The aggre-
gation of the degrees P into an overall membership m i
is illustrated in Section 2.3.2.
Two case or person types (i.e., case contexts or cat-
egories) are considered: SportsPerson, denoted by
CSP , and ArtisticPerson, denoted by CAP . The in-
tentions of the examined categories are given by the ab-
stract feature sets: CSP = {a1 , a2 , . . . , Money, . . . , am },
and CAP = {b1 , b2 , . . . , Money, . . . , bn }. The focus is
on the fuzzy primitive abstract feature Money the per-
son types CSP and CAP have in common4 . Further, two
according approximation scales, sSP and sAP , are estab-
lished so as to represent the different characteristics the
Money feature may possess within the categories CSP
and CAP respectively (see Figs. 3 and 4).
Consider the diagrams above. The linguistic term
set L Money = {poor, well-off, rich}, used to describe the
pre-defined feature Money, is defined within the scope
of the entire case base. Therefore, L Money is the same
across the categories CSP and CAP . However, different
graphs reflect the meaning a concept, such as poor, con-
veys in different contexts. As a result, the “normalised”
fuzzy numbers (e.g., approximately 5,000 in sSP , and
P1: VTL/EHE
Applied Intelligence KL450-01-Dubitzky May 13, 1997 15:35
Figure 3. Scale sSP for Money feature in category CSP ( p-function:
µ(Money)well-off ).
Figure 4. Scale sAP for Money feature in category CAP ( p-function:
µ(Money)rich ).
approximately 10,000 in sAP ) are also represented in a
context-specific fashion!
Suppose, in the CSP category, Money has a weight
of 10% (wSP = 0.10), and its prototypical value, there,
is expressed by the linguistic term well-off and the cor-
responding p-function µ(Money)well-off (thick-lined
graph).
Whereas in CAP , the Money feature contributes to
5% to the recognition of concept CAP (wAP = 0.05).
And individuals of type CAP would typically be rich
(term rich and p-function µ(Money)rich ).
Three unclassified individuals x, y, and z are
given by x := < x1,..., 37000,... >, y
:= < y1,..., "POOR",..., >, and z := <
z1,..., <"AROUND",25000,>,... >. The
specified values correspond to the Money attribute
(i.e., xMoney =37,000, yMoney = poor, zMoney =
around 25,000). With respect to this feature (and the
category specific weights and p-functions) it is now es-
tablished to what extent m a feature value contributes
to the overall membership of the individuals (x, y, z)
in the categories CSP and CAP respectively. In general,
with a feature’s prototypicality degree p and its weight
w, m evaluates to: m = p · w(m ∈ [0, 1]).
An Advanced Case-Knowledge Architecture 193
First, the category CSP with the associated approxi-
mation scale sSP , and the Money feature weight wSP is
considered (see also Fig. 3):
1) For the real number xMoney =37,000, the member-
ship function µ(Money)rich is found. This is not
CSP ’s p-function, therefore, the prototypicality de-
gree pxSP = 0. It follows m xSP = 0.
2) The linguistic term yMoney = poor matches the
membership function µ(Money)poor . Again, this is
not CSP ’s p-function, consequently, m ySP = 0.
3) Before the fuzzy number zMoney = around 25,000
can be evaluated, it has to be converted into the
corresponding normalised fuzzy number. This is
done by the mapping of zMoney ’s numeric expres-
sion (25,000) onto the corresponding membership
function in sSP ; this yields µ(Money)well-off . So the
freely expressed around 25,000 is equivalent to the
standardised approximately 30,000 (and therefore
with the term well-off ) within the considered con-
text. For well-off corresponds to CSP ’s p-function,
the prototypicality degree of zMoney = around
25,000 evaluates to pzSP = 1.00. It follows: m zSP =
pzSP · wSP = 0.10. This means that z’s Money fea-
ture value provides its maximal contribution, i.e.,
0.10, to z0 s classification as a sports person.
Now the same three individuals x, y, and z are
considered in the ArtisticPerson context, taking
into account the relevant approximation scale sAP and
weight wAP (see also Fig. 4):
1) With the crisply specified Money attribute,
xMoney =37,000, CAP ’s p-function µ(Money)rich can
be found. In this case—with the crisp feature value
and the definition of µ(Money)rich —it is possible to
precisely compute xMoney ’s prototypicality degree:
pxAP = −(1/15,000) · xMoney + 10/3 = 0.86. Con-
sequently: m xAP = pxAP · wAP = 0.043. That is, x’s
Money feature contributes to 4.3% to x’s categori-
sation as an artistic person.
2) and 3) Applying the above rules (implicitly given),
the reader can easily establish m yAP = m zAP = 0.
Considering above results, and the context-specific
Money characteristics expressed by the approximation
scales in the diagrams again, the reader may find that
the computed figures agree with our intuition. When
the same strategy was applied to the Coronary Heart
Disease risk assessment domain, the domain expert
P1: VTL/EHE
Applied Intelligence KL450-01-Dubitzky May 13, 1997 15:35
194 Dubitzky et al.
expressed a high degree of satisfaction and confidence
in the system’s behaviour.
2.2.3. Similarity and Membership Functions. In the
C4 architecture, it is explicitly allowed to encode prim-
itive abstract features using a fuzzy or crisp format.
When comparing features involving fuzzy values (lin-
guistic terms, fuzzy numbers), the decision of whether
one feature is worse or better than the other becomes
a non-trivial affair! The problem stems from the fact
that fuzzy numbers and linguistic terms represent many
possible real numbers that have different membership
degrees. That is to say, unlike real numbers, fuzzy num-
bers do not always yield a totally ordered set [15].
To illustrate this, the Money feature in the sports
person context CSP is considered again (see Fig. 3).
Suppose two base cases with the corresponding Money
feature values b1 and b2 , given by b1 := < "POOR"
> and b2 := < "APPROXIMATELY" 45,000 >,
are stored in the CSP category. The decision, based
on the abstract feature Money, as to which of the base
cases is more similar to a target case t (tMoney := <
"WELL-OFF" >) is not straightforward.
Chen and Hwang discuss several methods that
deal with the aggregation and ranking of entities de-
scribed by fuzzy attributes [10]. The C4 approach
is based on a relatively new and highly performant
method [10, p. 465], devised by Chen and Hwang,
that converts fuzzy numbers and linguistic terms into
crisp scores. These can then be used in conjunction
with a traditional Multiple Attribute Decision Method
(MADM) such as TOPSIS (Technique for Order Pref-
erence by Similarity to Ideal Solution). The Crisp Score
Method requires that the fuzzy numbers satisfy the
commonly assumed normal and convex criteria; the
method has proven to be robust against most types of
intersection that may occur between fuzzy sets [10].
Chen and Hwang have also shown the usefulness of
the method in MADM problems containing a mixture
of crisp and fuzzy data.
The following demonstrates this method. The crisp
score CS(Money)poor for the fuzzy number labelled by
linguistic term poor is computed (see scale sSP and
membership function µ(Money)poor in Fig. 3).
In general, for a fuzzy number FN, the formula to
compute the crisp score S(x)FN is defined as follows:
CS(x)FN = [S R (x)FN + 1 − SL (x)FN ]/2 (3)
In the equation, the score S R (x)FN represents the
µ(x)FN value where the right “leg” of the µ(x)FN
function and the line max(x) = x intersect. Similarly,
SL (x)FN represents the µ(x)FN value at the intersection
of the left “leg” of µ(x)FN and the line min(x) = 1− x.
(Note, max(x) and min(x) are defined with respect to
the normalised interval 0 ≤ x ≤ 1.)
Applied to the example and the fuzzy number (i.e.,
linguistic term) poor, the functions max(Money) =
(1/50,000) · Money, and min(Money) = 1 −
(1/50,000) · Money can be determined (see Fig. 3).
And the membership function for the term poor can be
derived as follows:

 +(1/5,000)Money,

 for 0 ≤ Money ≤ 5,000
µ(Money)poor =

 −(1/50,000)Money + 2,

for 5,000 < Money ≤ 10,000
(4)
With max(Money) and Eq. (4), upper part, the right
score S R (Money)poor = 0.18 is established. Likewise,
through min(Money) and Eq. (4), lower part, the left
score evaluates to: SL (Money)poor = 0.91. Now, with
Eq. (3), the (total) crisp score for the fuzzy number
labelled poor can be computed as: CS(Money)poor =
0.14.
In a similar fashion, the crisp scores
CS(Money)well-off = 0.54, and CS(Money)rich = 0.83
are worked out (the normalised fuzzy number approx-
imately 45,000, in the example, corresponds to the lin-
guistic term rich).
Since the crisp scores CS(Money)i constitute real
numbers, it is now possible to resort to “traditional”
ranking schemes in order to solve the similarity prob-
lem stated above. The Distance from Target Method
(see Eq. (5)) is employed to compute the distances
db1 t = 0.40 between b1 and t, and db2 t = 0.29 between
b2 and t. So, within the SportsPerson category, an
individual t, whose income is described by well-off, is,
at least Money-wise, more similar to an individual b2
(approximately 45,000 or rich) than to b1 ( poor).
2.2.4. Definition of Fuzzy Primitive Abstract Features.
To define a fuzzy primitive abstract feature and its pro-
totype derivative, two more fundamental C4 compo-
nents, namely the linguistic term and the fuzzy number
classes, need to be specified. For each C4 case base
there exists a globally pre-defined set T of linguistic
terms: T = {t1 , t2 , . . . , tn } (each term ti ∈ T is con-
structed from an atomic token or character sequence).
The set T is established by the domain expert. All lin-
guistic expressions used to describe fuzzy objects are
P1: VTL/EHE
Applied Intelligence KL450-01-Dubitzky May 13, 1997 15:35
derived from T . A subset P of T contains “close to”
or “proximity” terms (examples include nearly, more
or less, roughly). These terms serve to express the C4
fuzzy number construct. Non-fuzzy-number linguis-
tic terms are formed from elements of the linguistic
expression set E (e.g., very costly, low, extremely haz-
ardous), E = T − P. Note, a set X ⊂ T , chosen
to express the linguistic terms for a particular abstract
feature F, remains constant for F instances across the
entire case base!
Definition 1. The linguistic term class LT is defined
in terms of the set Pool of linguistic expressions (where
Pool ⊂ E). The instance variable term represents the
linguistic expression that a LT instance can assume;
term must be drawn from the “allowed” set Pool of
linguistic expressions (this constraint has to be en-
forced by the Create and accessor functions defined
on LT). Pool is a class-level variable, this means that
the associated set is shared by all instances of type
LT.
LT::=[ { term: T; class Pool: set <T>},
{ class Create, class AddTerms,
set_term, get_term, equal . . . }
].
The methods set term, get term, equal, . . .
express instance-level access methods, comparison op-
erators, etc. Create and AddTerms represent class-
level methods. Note, the class LT is a generic class
(it is never directly instantiated), user-defined classes
have to be derived from LT accordingly.
The following example illustrates the above con-
cepts. The class LTMoney represents the linguistic
terms used in connection with the previously intro-
duced Money feature. Via the is-a or inheritance re-
lation (denoted by ⊂), the user-defined linguistic term
class LTMoney inherits from the system-defined class
LT.
LT ⊂ LTMoney ::=
[ { currency: String },
{ class Create, class AddTerms,
set_term, get_term, equal,
print . . . }
].
The LTMoney class can add new data members
(e.g., currency), methods (e.g., print) and redefine
An Advanced Case-Knowledge Architecture 195
the polymorphic LT methods (e.g., AddTerms,
set_term). Now, the linguistic term class LT-
Money can be seeded with linguistic terms (e.g.,
AddTerms("POOR", "WELL_OFF")-- -->LTMoney ),
instantiated and used (e.g., set_term). For the sake
of brevity, this is not demonstrated.
Definition 2. On the analogy of the class LT, each
normalised fuzzy number in a C4 system is defined
through the generic class FN. FN consists of a shared
set of proximity terms (Pool ⊂ P), a value a FN instance
can assume—proximity term prox ∈ P and real number
r —and a set of methods.
FN::=[ { prox: T; r: Real; class Pool:
set <T> },
{ class Create, class AddTerms,
get_term, get_number, equal . . . }
].
In the definition, the meaning of the methods is anal-
ogous to those defined on the linguistic term class
above. Referring to the Money feature again, the
fuzzy number construct is illustrated by means of an
example:
FN ⊂ FNMoney ::=
[ { currency: String; scale_point:
Real },
{ class Create, class AddTerms,
get_term, get_number, equal,
print . . . }
].
Note, the reason why a user would like to supply his
or her own FN version is to accommodate and enforce
application-specific semantics and constraints.
With the definitions of the general linguistic term and
fuzzy number classes, given above, it is now possible to
define the fuzzy primitive abstract feature class FPAF.
For reasons that are explained in Section 2.3.3, the class
FPAF has a generic, system-defined superclass FAF
(fuzzy abstract feature).
Definition 3. C4’s fuzzy primitive abstract feature
class FPAF can simultaneously represent a particular
feature instance value in three different formats (repre-
sentational polymorphism), namely as linguistic term
term, fuzzy number f num, and real number r respec-
tively. Through the (static) polymorphic similarity
P1: VTL/EHE
Applied Intelligence KL450-01-Dubitzky May 13, 1997 15:35
196 Dubitzky et al.
method, a FPAF instance can compare itself with a
compatible feature value.
FAF ⊂ FPAF::=[ { term: LT; f_num: FN; r:
Real; proto: PrototypeFPAF },
{ class Create, similarity,
α, β, . . . }
];
similarity ::= [ (in t_af_value: LT;
out sim: Real) ];
similarity ::= [ (in t_af_value: FN;
out sim: Real) ];
similarity ::= [ (in t_af_value: Real;
out sim: Real) ];
similarity ::= [ (in t_af_value: FPAF;
out sim: Real) ].
To accomplish above-defined functionality, each
FPAF feature instance participates in a binary relation-
ship with a prototype primitive abstract feature object
proto. For a particular case category C and a FPAF
class F, the relationship R between the set I of F’s
instances in C, and the associated prototype object p,
is defined by (1-to-many): R : I (M) ↔(1) p. That
is, each FPAF instance in a category is associated with
a single prototypical counterpart. This concept allows
to represent context-specific feature characteristics. To
achieve such a context-dependency, the similarity
methods defined on FPAF delegate the actual compu-
tation to the corresponding method defined on proto.
By routing the similarity strategy through components
defined on the base cases themselves, the case designer
has an “intervention point” to check and enforce case-
level semantics.
It is important to note that the member classes LT,
FN, and PrototypeFPAF are modelled as generic
classes, this means that instances of their subclasses
(e.g., LTMoney) can participate to form an actual fea-
ture instance.
Before the FPAF feature class can be illustrated with
an example, it is necessary to look at the definitions
of the classes PrototypeFPAF and ApproxScale
(approximation scale).
Definition 4. The ProtoypeFPAF class is akin to
the FPAF class defined above, in that, it can take on
instance values of mixed fuzzy and crisp format. How-
ever, its main difference is the capability to establish
a prototypicality degree p for a target case feature
t af value. It defines the weight slot (expressing the
category-specific relevance weight of a feature), and
an approximation scale scale. The methods prototypi-
cality and similarity compute the according scores ( p,
sim) for a compatible target case feature t af value and
base case feature respectively (t af value, b af value).
Prototype ⊂ PrototypeFPAF ::=
[ { term: LT; f_num: FN; r: Real;
weight: Real; scale:
ApproxScale },
{ prototypicality, similarity,
α, β, . . . }
];
prototypicality ::= [ (in
t_af_value: LT; out p:
Real) ];
similarity ::= [ (in t_af_value,
b_af_value: LT; out sim:
Real) ];
Note, the methods prototypicality and simi-
larity are defined polymorphically (overloaded ver-
sions are not shown in the definition), so as to accept
input values of the type FPAF, FN, Real and LT.
The generic superclass Prototype is needed to de-
fine the PrototypeFCAF class (see below).
Definition 5. On the analogy of the methods proto-
typicality and similarity, specified in Definition 4, the
class ApproxScale defines the corresponding coun-
terparts. The collection type member scale realises
the ordered set of tuples consisting of: mem function
(membership function), f num (normalised fuzzy num-
ber), term (linguistic term), and cs (pre-computed crisp
score). The member p function represents an index
into the scales vector that identifies the p-function of
a particular ApproxScale instance.
ApproxScale ::=
[ { scales: vector< term: LT; f_num:
FN; cs: Real; mem_function:
MF >; p_function: Integer },
{ prototypicality, similarity,
convert, α, β, . . . }
];
prototypicality ::= [ (in
t_af_value: LT; out p: Real) ];
similarity ::= [ (in t_af_value,
b_af_value: LT; out sim:
Real) ];
convert ::= [ (in r: Real; out
t: LT) ].
P1: VTL/EHE
Applied Intelligence KL450-01-Dubitzky May 13, 1997 15:35
In the definition, the class MF constitutes a flexible
means to realise any type of function; at this stage, its
implementation is identical to the function/predicate
object concept described in [27]. The method con-
vert represents a group of polymorphic functions
used to realise the mappings between the various for-
mats (including the crisp scores). To compute the ac-
cording scores, the polymorphically defined methods
prototypicality and similarity resort to the
corresponding convert functions.
An example: Based on the LTMoney and the FN-
Money examples introduced above, a user-defined
money approximation scale MoneyScale, and a pro-
totype fuzzy primitive abstract feature MoneyProto,
the fuzzy primitive abstract feature Money can be
defined and instantiated according to the following
steps:
1. Define LTMoney and FNMoney as subclass of the
system-provided generic linguistic term and fuzzy
number class LT and FN respectively (see examples
above).
2. Define the set M (for example: M = {m 1 , m 2 , m 3 })
of context-specific membership function classes
based on the generic membership function class MF.
There has to be a function m i ∈ M for each linguis-
tic term represented in LTMoney.
3. Define and instantiate context-dependent approx-
imation scale class MoneyScale as subclass of
ApproxScale. When a MoneyScale instance
is constructed, instances (or instance references) of
the classes LTMoney, FNMoney, m1, m2, and
m3 can be passed via MoneyScale’s Create mes-
sage (dynamic binding). For example (the Cre-
ate method has to establish the corresponding crisp
scores cs1 , cs2 , and cs3 ):
ApproxScale ⊂ MoneyScale
::= [ (* . . . *) ].
money_scale_context_1 :=
< Create( lt1, . . . , fn1, . . . , m1, . . . )
--
--> MoneyScale >
4. Define prototype fuzzy primitive abstract feature
MoneyProto (needed in Step 5) as subclass of
the system-defined class PrototypeFPAF. In-
stantiate MoneyProto along with context-relevant
weight and the approximation scale money_
scale_context_1. For example (prototypical
An Advanced Case-Knowledge Architecture 197
Figure 5. Complex object structure modelling the abstract feature
anatomy of a case.
feature values are not shown):
PrototypeFPAF ⊂ MoneyProto::=[ (* . . . *) ].
money_proto_fpaf_context_1 := < Create
( money_scale_context_1, 0.50 )--
-->
MoneyProto >
5. Finally, define and instantiate fuzzy primitive ab-
stract feature class Money:
FPAF ⊂ Money ::= [ (* . . . *) ].
some_money := < Create("AROUND", 5000)
--
--> FNMoney >
income := < Create(money_proto_fpaf_
context_1, some_money) --
-->
Money >
2.3. Complex Abstract Features
Usually, a case is perceived as an entity with a complex
internal structure [1]. Due to the “absolute judgement”
phenomenon [24], the complexity of a structured case,
in terms of its abstract features, is limited to a nesting
depth of n ≤ 7 ± 2. The same boundary applies to the
number k of abstract features each complex abstract
feature (hence, the whole case) can consist of at a given
level (k ≤ 7 ± 2). The diagram below illustrates this
structural organisation of a single case with respect
to its abstract features f 1 , . . . , f jm...q ( j, m, p, q, . . . ≤
7 ± 2).
In practice, however, a particular abstract feature
skeleton of a case arrangement will not exploit all possi-
ble dimensions in this hierarchy (see Fig. 5). However,
with additional surface features, accompanying the ab-
stract features, a case’s overall complexity can exceed
the above-stated limits.
In C4, all non-symbolic terminal case abstract
features are represented by fuzzy primitive abstract
features. The similarity and prototypicality assessment
between two abstract features (and therefore the cases)
P1: VTL/EHE
Applied Intelligence KL450-01-Dubitzky May 13, 1997 15:35
198 Dubitzky et al.
is established in a recursive fashion; recursion termi-
nates at the level of fuzzy primitive abstract features.
At this level, the previously discussed approximation
scales (held in a prototype case for each category) come
to bear to compute the similarity/prototypicality scores
of corresponding fuzzy primitive abstract features.
However, when aggregated scores are to be estab-
lished, for a complex feature made up of constituents
of different format (including complex features), two
questions arise:
1) How can differently encoded sub-features of a com-
plex abstract feature be systematically combined in
order to reach at an overall score a that can be com-
pared with another score b?
2) In addition to (1), if, as it is commonly the case with
MADM and CBR problems, the attributes’ units of
measurement are incommensurable, how can mean-
ingful collective scores be formed?
In the literature [10] several methods are pro-
posed that deal with problem (1). For the C4 frame-
work, the Crisp Score Method has been chosen (see
Section 2.2.3), as it, via crisp scores, allows to fall back
upon non-fuzzy schemes (e.g., MAXIMAX, EBA,
LAM). Moreover, this method has been shown to be
successful in real-world problems where it is often
the case that both crisp and fuzzy data coexist [10,
(pp. 465–486), 13]. Another appealing feature of the
method is its robustness—i.e., its ability to produce use-
ful orderings—against intersecting fuzzy sets (“over-
lapping” fuzzy numbers). Finally, the Crisp Score
Method has proven to be superior, in terms of per-
formance, over other approaches in applications where
hundreds/thousands alternatives (cases) with few fea-
tures, or few alternatives (cases) with hundreds of fea-
tures need to be ranked [10].
Originally, in the first phase, the Crisp Score Method
requires the pre-instalment of an ad hoc scale conglom-
erate. In the C4 architecture, however, this somewhat
problematic approach is avoided, since approximation
Figure 6. Approximation scales for features Total depending on the categories CI , CII and CIII (from left to right).
scales are carefully established for each individual
fuzzy abstract feature within the context of a specific
category. In fact, the initial knowledge acquisition stage
has shown that the approximation scales serve as an
elegant communication platform between the domain
expert and knowledge engineer.
The solution to question (2) is normalisation; this
strategy fits well into the C4 scheme involving nor-
malised weights, prototypicality and membership de-
grees, and crisp scores respectively.
So eventually, when comparing and ranking cases,
a C4 system processes the crisp score and normalised
real number of corresponding features. If, and only if,
the target case feature value t and the base case fea-
ture value b are given in crisp number format, then
t’s and b’s normalised values (indicated by “*”) are
used. For example, ht (age = 35), b(age = 51)i
normalise
−→ ht(age∗ = 0.30), b(age∗ = 0.45)i. This is in
keeping with the original intention of fuzzy set theory
which is to incorporate human imperfect perceptions,
subjective judgement, and imperfect information into
a decision model. When decision data can be precisely
captured, such data should not be forced into a fuzzy
format because it will complicate the already complex
decision-making problem.
Otherwise, for all other possible combinations, crisp
scores (indicated by “+”) for t and/or b must be es-
tablished. These scores are then subjected to the ac-
cording method. For example, ht (Total = “HIGH”),
crisp score
b(Total = “VERY HIGH”)i −→ ht (Total+ =
0.56), b(Total+ = 0.74)i (compare values with left
scale in Fig. 6). In case of a mixed fuzzy/crisp feature
value combination (e.g., ht (Total = “VERY HIGH”),
b(Total = 7.50)i) the crisp value c must first be con-
verted into that fuzzy number Ai whose x̂i is closest to
c, i.e., that Ai where min(|c − x̂i |). For this to work
it is required that for each Ai ∃ a unique x̂i such that
µ(x̂i ) Ai = 1, for µ(xi ) Ai : U → [0, 1], xi ∈ U . For
fuzzify
example, b(Total = 7.50) −→ b(Total0 = “HIGH”).
This conversion is somewhat ad hoc as it does not take
P1: VTL/EHE
Applied Intelligence KL450-01-Dubitzky May 13, 1997 15:35
into account a partial membership of c in Ai . In [13]
an approach is described that deals with this problem
more consistently, for reasons of conciseness it is not
discussed in this paper.
The mixed format and structured feature scoring
scheme is demonstrated by means of an example from
the Coronary Heart Disease risk assessment domain.
This is also the field to which the C4 architecture has
been applied in the form of a prototype that is currently
being extended.
2.3.1. Coronary Heart Disease Risk Assessment.
Coronary Heart Disease (CHD) is a degenerative dis-
ease which is the result of an increase of atheroma
in the coronary artery walls leading to total or partial
occlusion. The resulting clinical feature is Myocar-
dial Infarction (heart attack) and subsequently sudden
death [28].
The main risk factors related to this condition involve
physical inactivity, smoking, hypertension, stress,
hypercholesterolaemia, etc. This complex multifacto-
rial disease makes it difficult for clinicians to accurately
assess the likelihood of a cardiac event. Currently, sta-
tistical multivariate analysis methods are used to mea-
sure risk on those asymptomatic patients who, nev-
ertheless, present one, two or more CHD risk factors
[23]. Although statistical methods provide information
regarding the likelihood of CHD event through system-
atic numerical calculation, it does not take in account
the individual as a whole, neither provide sophisticated
human-like reasoning.
Furthermore, Northern Ireland has got one of the
highest rates of CHD in the world and much of the at-
tention today is focused on precise screening strategies
and preventative measures. Therefore, more investiga-
tion is needed for the establishment of better predictive
systems for screening the pre-symptomatic stage be-
fore the onset of CHD state.
A better insight into the understanding of the under-
lying mechanisms of CHD could be the inclusion of
CBR as a new promising approach of early risk identi-
fication in order to provide more accurate intervention
strategies.
2.3.2. Prototypicality and Similarity Computation
for Fuzzy Complex Objects. In the following ex-
ample the retrieval of subjects or cases, represented
by two fuzzy complex abstract features, is demon-
strated. This involves the fuzzy classification of a tar-
get case, and subsequent determination of the most
An Advanced Case-Knowledge Architecture 199
relevant stored base case. The case base is organised as
follows:
The case base B is represented by three categories
CI , CII , and CIII , these relate to the CHD risk type
of the cases they organise. Category CI corresponds
to subjects that have a high CHD risk because of their
cholesterol levels, cases in CIII constitute stress-related
risk types, and in category CII are cases that incline to
risk that is caused by both factors.
Each base case b ∈ B is given by the fuzzy complex
abstract feature pair: [ Stress, Cholesterol ].
Both features are broken down into two fuzzy primitive
abstract features, namely: Nervousness and Worry,
and LDL and Total. The Nervousness and Worry
values originate from a commonly used stress ques-
tionnaire, they represent the Stress feature, whereas
LDL (Low Density Lipoproteins) and Total (total cir-
culating cholesterol in the blood) are taken from blood
sample analysis and represent the Cholesterol fea-
ture. Similarly to the Money example (Section 2.2.2),
there is an approximation scale for each fuzzy primi-
tive abstract feature for each context Ci . The diagram
below illustrates the context-dependent approximation
scales for the Total feature.
The target case t, used throughout this example, is
described by the following combination of feature in-
stances t:= < < "ALMOST NEVER", "OCC-
ASIONALLY">, <8.00,3.70> >; where the first
pair represents the Stress ([Nervousness,
Worry]), and the second the Cholesterol ([To-
tal, LDL]) values. Note, the target case is presented
as a structured object, rather than as flat feature vector.
This is achieved by C4’s feature extraction component
which constructs a category-specific target case from a
surface feature vector [14].
To classify t, its constituent feature values have to
be matched against the p-functions of the correspond-
ing approximation scales in the three categories (see
Section 2.2.2). For example (see Fig. 6), the target
case’s feature t(Total = 8.00) yields the prototypicality
degrees p1 = 0.16 (‘on’ p-function µ(Total)very-high
in C1 ), p2 = 0 and p2 = 0 (‘beside’ p-functions in cat-
egory C2 and C3 ). Fuzzy feature values evaluate to a
prototypicality degree p(t, pCi ) = 1.00, for linguistic
terms, if, and only if, the linguistic value t is identi-
cal with the p-function term pCi of the corresponding
prototype feature, it is 0 otherwise. And p(t, pCi ) =
1.00, in case of fuzzy numbers, if, and only if, the
real part of the normalised fuzzy number intersects
with the p-function of the corresponding prototype
P1: VTL/EHE
Applied Intelligence KL450-01-Dubitzky May 13, 1997
200 Dubitzky et al.
feature, it is 0 otherwise. For example, p( t (Total =
“HIGH”), pC1 (Total = “VERY HIGH”)) = 0.00
and p(t(Total = “AROUND” 11.00), pC1 (Total =
“VERY HIGH”)) = 1.00.
This process yields the prototypicality degrees pi j
based on which the overall category membership de-
grees m i can be computed—these values are given be-
low in table format.
Assuming uniform feature weights wk = 0.50 at
each complex abstract feature level k across the three
categories (i.e., wNervousness = wWorry = wTotal = wLDL
= wStress = wCholesterol = 0.50), the membership de-
grees m i are effectively
P established byP means of the for-
mula m k j = j=1···n P wk j · pk j , where j=1···n wk j = 1
must hold, and m i = k=1···m m k . For example: m I =
[0.5(0.5 · 1.00 + 0.5 · 1.00)] + [0.5(0.5 · 0.16 + 0.5 ·
0.41)] = 0.64.
Each category Ci stores a minimal membership de-
gree di ∈ [0, 1]. For case storage/retrieval only those
categories Ci are considered where the target case’s
membership degree m i > di . The rationale behind this
is that each category Ci in a case base can be consid-
ered as a highly specialised case base in its own right,
and with its own constraints and concept boundaries.
A domain expert may feel comfortable to go ahead
with a category X of which a new entity t is a mem-
ber to a degree of 0.80, but not with a category Y for
which the same entity t has scored an identical mem-
bership degree; for the two categories X and Y may
be perceived as different, intra-domain application ar-
eas. This idea is similar to the varying inter-domain
requirements in terms of how close a match between
the target and the retrieved case has to be. Generally,
interpretative tasks require a low match, around 0.30,
and in problem-solving tasks a retrieved case should
be similar to a high degree, about 0.80 [22]. In the ex-
ample, a uniform minimal membership degree d = dI
= dII = dIII = 0.60 is assumed. As the target case in the
example scores the membership degrees m 1 < m 2 < d
the categories CII and CIII are not further examined (see
Table 1).
Table 1. Prototypicality and category membership de-
grees for the target case t.
pi j
Nervousness Worry Total LDL
CI 1.00 1.00 0.16 0.41
CII 0.00 1.00 0.00 0.00
CIII 0.00 0.00 0.00 0.00
15:35
Intuitively, this result, that t is a member of the high-
cholesterol-low-stress category CI , rather than one
of the categories CII (medium-cholesterol-medium-
stress) or CIII (low-cholesterol-high-stress), seems cor-
rect. As far as t’s stress levels are concerned (which,
in CI , are prototypically of the moderate kind) t has
matched the corresponding p-functions in that cate-
gory (values almost never and occasionally). And
in terms of critical cholesterol levels, prototypically
for members of CI , t, on the grounds of high To-
tal and LDL values, has higher prototypicality de-
grees in CI than in the other categories. (for the
sake of conciseness, the p-functions for Nervous-
ness, Worry and LDL are not illustrated in the
paper).
Now the focus is on selecting the best-match case in
category CI . Suppose in the category CI are four stored
base cases: bI1 , bI2 bI3 and bI4 . These cases, including
their constituent feature values, are shown in the table
below together with the already categorised base case t.
The numbers after the “/” constitute the corresponding
crisp scores (marked by a “+”) and normalised real
numbers (indicated by an “*”) respectively5.
When the classified target case t enters the category
CI , for the determination of the most similar base case
bIx , its crisp score and normalised value representation
is created via the prototype case p I stored in CI (recall,
it is actually pI that is equipped with the respective
approximation scales). To find the desired base case,
the Distance from Target Method (see below) with the
above-introduced uniform weight distribution is used
(w = 0.50).
" #(1/2)
X
d= (w j )2 (b j − t j )2 , (5)
j=1···n
where b j is the jth abstract feature value of the complex
feature or case in a particular category C. Further, t j
represent corresponding target case feature values, and
w j the category-specific normalised weight of the jth
abstract feature. The result d reflects the conceptual
distance between two corresponding complex abstract
features and cases respectively.
With w = 0.50, the distances dIi between the base
cases bIi and the target case t evaluate to: dI1 = 0.0775,
mi
dI2 = 0.0738, dI3 = 0.0845 and dI4 = 0.0825. For
0.64 example (with a = 0.52 = 0.25):
0.25 dI2 = {a [(a (0.5 − 0.23)2 + a(0.5 − 0.5)2 )(1/2) ]2
0.00
+ a[(a (0.63 − 0.51)2 + a(0.59 − 0.59)2 )(1/2) ]2 }(1/2)
= 0.0738.
P1: VTL/EHE
Applied Intelligence KL450-01-Dubitzky May 13, 1997 15:35
Table 2. Base cases bI j and target case t.
Stress
Nervousness Worry
bI1 ALMOST NEVER/0.23+ OCCASIONALLY/0.50+ VERY HIGH/0.74+
bI2 SOMETIMES/0.50+ OCCASIONALLY/0.50+ 10.00/0.74+ | 0.63∗
bI3 ALMOST NEVER/0.23+ HARDLY EVER/0.17+
bI4 ALMOST NEVER/0.23+ HARDLY EVER/0.17+
t ALMOST NEVER/0.23+ OCCASIONALLY/0.50+ 8.00/0.74+ | 0.51∗
+ = crisp scores, ∗ = normalised real numbers.
Note, how the crisply encoded features—or for that
matter their normalised values—are used where pos-
sible (e.g., (0.63 − 0.51)2 ). Otherwise, the procedure
resorts to crisp scores, even when one value is given
in crisp format! Also note the recursive nature of the
calculation; the intermediate values in squared brack-
ets are interpreted as distance values at the level of the
“outer” distance computation.
So base case bI2 is the one that is most similar to the
target case t. Considering Table 2 again one would,
perhaps, initially be in favour of case bI1 , for it is the
only one that has two feature values identical to the
target case t (almost never and occasionally). How-
ever, there is some significant disagreement between
the crisply specified features bI1 (LDL = 6.20) and
t (LDL = 3.70); in the corresponding scale, these two
values ‘stretch’ across two fuzzy numbers. The cases
bI2 , bI3 and bI4 , on the other hand, have only a single
value in common with the target case t, but lack the
presence of a significant difference over the remaining
corresponding value pairs. So, intuitively, it is not easy
to tell which of the base cases should be selected.
2.3.3. Definition of Fuzzy Complex Abstract Features.
The definition of fuzzy complex abstract features is
straightforward since they are defined based on the un-
derlying fuzzy primitive abstract feature concept (see
Section 2.2.4). Fuzzy primitive abstract features and
fuzzy complex abstract features are conceptually tied
together by the same set of services they can provide.
This is reflected by the generic class FAF (fuzzy ab-
stract feature).
Definition 6. A FCAF class is defined in terms of 1
to n constituent abstract features f i of primitive and/or
complex type (1 ≤ i ≤ n and n ≤ 7 ± 2). The
similarity function defined on FCAF takes a compatible
target case feature value t af value as input argument
and produces a similarity score sim (sim ∈ [0, 1]). The
An Advanced Case-Knowledge Architecture 201
Cholesterol
Total LDL mi
6.20/0.90+ | 0.76∗ 0.75
HIGH/0.59+ 0.67
9.20/0.74+ | 0.58∗ 3.80/0.59+ | 0.47∗ 0.64
VERY HIGH/0.74+ HIGH/0.59+ 0.75
3.70/0.59+ | 0.45∗ 0.64
prototype feature proto is used to accommodate the
category-specific weight for FCAF instances.
FAF ⊂ FCAF ::=
[ { f1: FAF; f2: FAF; . . . ; fn:
FAF; proto: PrototypeFCAF },
{ class Create, similarity, α,
β, . . . }
];
similarity ::= [ (in t_af_value:
FCAF; out sim: Real)} ].
When comparing a compatible target feature t, the
similarity method defined on the base case feature
b delegates t’s relevant constituent abstract features to
the corresponding members in b. Eventually b’s sim-
ilarity service processes the intermediate proxim-
ity values produced by the feature’s constituent abstract
features, subjects them to the chosen similarity regime
(e.g., Distance from Target Method), and passes the
according scores to the encompassing construct (com-
plex feature or case). In the above example, the simi-
larity method associated with bI2 ’s Stress feature
instance would have computed: dIStr = (0.52 · 0.272 +
0)(1/2) = 0.135, and of bI2 ’s Cholesterol’s simi-
larity the value: dICol = ( 0.52 · 0.122 + 0 )(1/2) =
0.06, and the similarity function attached to the case
bI2 itself: dI2 = [0.52 (dIStr )2 + 0.52 · (dICol )2 ](1/2) =
0.0738. The actual resemblance or distance figures
between the feature values (e.g., 0.27, 0, 0.12, 0) are
computed through the similarity methods defined
on the fuzzy primitive abstract features.
The class PrototypeFCAF plays a similar role as
the PrototypeFPAF class in Definition 4. However,
it does not define an approximation scale, nor a sim-
ilarity method, for a particular comparison strat-
egy is handled by the cases themselves, and scales are
only relevant on the level of primitive abstract features.
The major purpose of this class is to represent and
P1: VTL/EHE
Applied Intelligence KL450-01-Dubitzky May 13, 1997 15:35
202 Dubitzky et al.
accommodate the context-defining prototypical com-
ponents of a case category, and to directly establish the
membership degree of a target case concept. Like the
class FCAF, PrototypeFCAF makes use of generic
Prototype references, rather than static object vari-
ables, so as to dynamically assign fuzzy complex as
well as fuzzy primitive abstract features.
Definition 7. A PrototypeFCAF class defines n
Prototype features f i (these references can be
bound to instances of type PrototypeFPAF and
PrototypeFCAF, respectively). The weight mem-
ber represents a relevance weight the entire complex
feature carries. Through the method prototypicality,
a compatible complex feature’s membership or proto-
typicality degree p is established.
Prototype ⊂ PrototypeFCAF ::=
[ { f1: Prototype; f2: Prototype;
. . .; fn: Prototype; weight: Real; },
{ prototypicality, α, β, . . . }
];
prototypicality ::= [ (in
t_af_value: FCAF; out p:
Real) ];
3. Summary, Conclusion, Related
and Future Work
This paper presented a promising, advanced case-
knowledge representation framework, called C4,
which derives its representational expressiveness from
a versatile fuzzy abstract feature mechanism. It was
shown how fuzzy primitive and fuzzy complex abstract
features serve as a flexible case-knowledge representa-
tion platform allowing for a polymorphic specification
of crisply and fuzzily encoded case features. More-
over, a systematic classification and similarity regime,
based upon pre-computed crisp scores and normalised
real-numbered features, was presented. Another de-
gree of versatility of the C4 architecture is afforded by
the dynamically allocatable approximation scale con-
cept. Built around self-contained, agent-like entities
(i.e., context, category, base case, prototype case, fuzzy
abstract feature, approximation scale, function object,
etc.), and in compliance with essential and advanced
OO mechanisms, the architecture seems very viable,
easy to maintain and extend [14].
In an experimental set-up the C4 scheme has been ap-
plied to set S of 120 middle-aged, male subjects which
were tested over a period of three years. The case data
is comprised of clinical measurements, aerobic fitness
levels, and state and trade anxiety values. Its composi-
tion is a mixture of crisp and fuzzy information. Con-
ventional CBR schemes offer little to correctly treat
this type of case information, C4, on the other hand,
provides a systematic incorporation of fuzzy and crisp
features, and overlapping case clusters. When, for ex-
ample, asked to assign a case to exactly one category,
the domain expert frequently expressed discomfort, as
he could not easily discard other categories. On the
other hand, when a case was automatically classified
in more than one category (with the according mem-
bership degrees), the expert often agreed. Tests of the
retrieval mechanism (with the subset B (base cases),
and T (target cases) of S) have confirmed the viabil-
ity of this approach. Automatic adaptation, which con-
sist of advising patients of how to reduce their CHD
risk, is not automated at this stage. The “bottom-up”
case structuring, around class-sensitive approximation
scales, has also turned out to serve as an easy-to-use,
natural communication platform between the knowl-
edge engineer and the domain expert.
Only recently the CBR community has shifted to-
wards knowledge-intensive, as opposed to syntac-
tical, approaches [1, 28]. Some works explore the
exemplar-based dimension in conjunction with proto-
type cases [3, 4, 25]. Generally, those approaches pay
little attention to the changing characteristics of a fea-
ture type with in the frame of discernment of a case
base. Neither do they take into account the underly-
ing uncertainty, that is commonly encountered when
case features are to be expressed, in an explicit, me-
thodical fashion. Some relevant work may be found in
the database community [7, 17]. Also, little work has
been done on the combination of exemplar-based and
memory-based schemes.
Currently, there is work underway to integrate
“higher-level”, holistic linguistic terms into the C4
framework (see Section 2.1). Information summaries
of this kind seem to play a major role in human reason-
ing, in addition, such aggregation of complex circum-
stances into imprecise linguistic expressions appears
to fit well into the Fuzzy Logic and CBR paradigm.
To achieve this sort of knowledge representation, an
approximation scale for fuzzy complex abstract fea-
tures is needed, so as to accommodate a set of mem-
bership functions along a normalised “0-to-1” scale.
Additionally, there has to be a function that maps the
constituent features onto the holistic term scale (the
reverse mapping seems meaningless). Another aspect
that is currently receiving attention is a similarity metric
P1: VTL/EHE
Applied Intelligence KL450-01-Dubitzky May 13, 1997 15:35
based on the features’ prototypicality degrees. As re-
ported in [14], an earlier version of the C4 scheme
has been integrated in an object-oriented database
management system; more work along those lines is
needed.
Acknowledgment
Philippe Lopes, Human Performance Laboratory, Uni-
versity of Ulster, Jordanstown, Ireland.
Notes
1. This name was primarily chosen because of its simplicity; it is
based on the four agent-like components by means of which struc-
tural and operational case-knowledge is expressed: case base,
context, category and case.
2. The notation “M() ⇒ C” denotes the class-level message M sent
to the class C. To express the binding of a class instance i (in this
case denoted by the bracket pair “< · · · >”) to an object variable
v, the symbolism “v := i” is used. The notation is based on
ODMG’s Object Model and Object Definition Language, and on
OMG’s Interface Definition Language [8, 11].
3. As there are not many reported works on Exemplar Based
Reasoning involving prototypes, nobody—to the best of our
knowledge—has dealt with the context-dependency issues in this
connection.
4. The C4 architecture explicitly allows a particular case x to belong,
to a certain degree, into more than one category. For example,
a person x may belong to the CSP (membership degree 0.80) as
well as to the CAP (degree 0.72) category.
5. The normalised value v ∗ for a crisp, real-numbered primitive fea-
P 18. A. Goel, J. Kolodner, M. Pearce, R. Billington, and C. Zimring,
ture instance v is established by v ∗ = v/[t 2 + i=1···n (ri )2 ](1/2) ,
where ri represents all crisply defined instances of a particular
fuzzy primitive abstract feature type F in a category; t denotes
the crisp target case instance of F.
References
1. A. Aamodt, “A knowledge-intensive approach to problem solv-
ing and sustained learning,” Ph.D. dissertation, University of
Trondheim, Norwegian Institute of Technology, 1991.
2. A. Aamodt and E. Plaza, “Case-based reasoning: Foundational
issues, methodological variations, and system approaches,”
AICOM, vol. 7, no. 1, March 1994.
3. J.S. Aikins, “Prototypical knowledge for expert systems. A ret-
rospective analysis,” in Artificial Intelligence, vol. 59, pp. 207,
1993.
4. R. Bareiss, Exemplar-Based Knowledge Acquisition: A Uni-
fied Approach to Concept Representation, Classification, and
Learning, Academic Press: Boston, 1989.
5. R. Brandau, A. Lemmon, and C. Lafond, “Experience with
extended episodes: Cases with complex temporal structure,”
in Proc. Case-Based Reasoning Workshop, Morgan Kaufmann
Publishers, Inc., 1991.
An Advanced Case-Knowledge Architecture 203
6. M.G. Brown, “An underlying memory model to support case
retrieval,” in Proc. First European Workshop on Case-Based
Reasoning, Kaiserslautern, Germany, 1993, p. 20.
7. B.P. Buckles and F.E. Petry, “A fuzzy representation of data for
relational databases,” in Fuzzy Sets and Systems, vol. 7, p. 213,
1982.
8. R.G.G. Cattel (Ed.), The Object Database Standard: ODMG
(1.1), Morgan Kaufmann Publishers: California, 1994.
9. S.-J. Chen and C.-L. Hwang, Fuzzy Multiple Attribute Decision
Making, Methods and Applications, Springer Verlag, 1992.
10. Y. Cheng, “Context-dependent similarity,” in Uncertainty in Ar-
tificial Intelligence 6, North-Holland, p. 42, 1991.
11. Common Object Request Broker: Architecture and Specifica-
tion, The Object Management Group and X/Open, 1991.
12. W. Dubitzky, F. Carville, and J.G. Hughes, “Case-level knowl-
edge modelling,” in Proc. Irish Conference on Artificial Intelli-
gence and Cognitive Science, 1993.
13. W. Dubitzky, A. Schuster, J.G. Hughes, and D.A. Bell, “Concep-
tual distance of numerically specified case features,” in Proc. The
Second New Zealand International Two-Stream Conference on
Artificial Neural Networks and Expert Systems, Dunedin, New
Zealand, 1995, p. 210.
14. W. Dubitzky, J.G. Hughes, and D. Bell, “Knowledge Manage-
ment via the synergy of case-knowledge and object-oriented
information management,” to appear in the Proc. Third World
Congress on Expert Systems, Korea, Feb. 1996.
15. D. Dubois and H. Prade, “Fuzzy sets in approximate reasoning,
Part 1: Inference with possibility distributions,” in Fuzzy Sets
and Systems, North Holland, vol. 40, p. 143, 1991.
16. A. Foß (Ed.), “FABEL: Similarity concepts and retrieval
methods,” FABEL Report Number 13, Gesellschaft fu̇r
Mathematik und Datenverarbeitung mbH, Sankt Augustin, Ger-
many, 1994.
17. R. George, B.P. Buckles, and F.E. Petry, “Modelling class hier-
archies in the fuzzy object-oriented data model,” in Fuzzy Sets
and Systems, vol. 60, p. 259, 1993.
“Towards a case-based tool for aiding conceptual design problem
solving,” in Proc. Case-Based Reasoning Workshop, Washing-
ton D.C., 1991, p. 109.
19. I. Grahamand and P.L. Jones, Expert Systems: Knowledge,
Uncertainty Decision, Chapman and Hall, Ltd.: New York,
1988.
20. J.G. Hughes, Object-Oriented Databases, Prentice Hall Inter-
national (UK) Ltd., 1991.
21. G.J. Klir and T.A. Folger, Fuzzy Sets, Uncertainty and Informa-
tion, Prentice Hall: Englewood Cliffs, NJ, 1988.
22. J. Kolodner, Case-Based Reasoning, Morgan Kaufmann Pub-
lishers, Inc.: San Mateo, CA, 1993.
23. P. Lopes, R.H. Mitchell, and J.A. White, “The relationships be-
tween respiratory sinus arrhythmia and coronary heart disease
risk factors in middle-aged males,” in Automedica, vol. 16, p. 71,
1994.
24. G.A. Miller, “The magic number seven, plus or minus seven,”
in Psychological Review, vol. 63, p. 81, 1965.
25. B. Porter, R. Bareissan, and R Holte, “Concept learning and
heuristic classification in weak theory domains,” in Artificial
Intelligence, vol. 45, nos. 1/2, p. 229, 1990.
26. E.H. Ruspini, “Possibility as similarity: The semantics of fuzzy
logic,” in Uncertainty in Artificial Intelligence 6, North-Holland,
p. 271, 1991.
P1: VTL/EHE
Applied Intelligence KL450-01-Dubitzky May 13, 1997 15:35

204 Dubitzky et al.

27. A. Stepanov and L. Meng, “The standard template library,” January 1995. He received a BSc in Applied Physics from the Uni-
Hewlett-Packard Laboratories, Palo Alto, CA 94304, 1994. versity of Munich, Germany, in 1990. His current research inter-
28. Study Group, European Atherosclerosis Society, “Strategies for ests include logical systems, expert systems, non-linear and dynamic
the prevention of coronary heart disease: A policy statement of systems.
the european atherosclerosis society,” in European Heart Jour-
nal, vol. 8, p. 77, 1987.
29. L.A. Zadeh, “Outline of a new approach to the analysis of com-
plex systems and decision processes,” IEEE Transactions on Sys-
tems, Man, and Cybernetics, vol. SMC-3, no. 1, p. 28, Jan. 1973.

John G. Hughes is a Professor of Computing and the Dean of the

Faculty of Informatics at the University of Ulster. He is also the
Director of the Northern Ireland Knowledge Engineering Labora-
tory (NIKEL). He received a BSc and PhD in Mathematics from
the Queen’s University of Belfast in 1975 and 1978, respectively.
Werner Dubitzky is a full-time Research Officer and part-time PhD His current research interests include database technology, artificial
student in the School of Information and Software Engineering at the intelligence and knowledge engineering.
University of Ulster (expected submission of PhD thesis in Summer
1997). He received a BSc in Electrical Engineering from the Univer-
sity of Augsburg, Germany, in 1991. His current research interests
include object-oriented databases, case-based reasoning, fuzzy logic,
evidential reasoning and knowledge engineering.

David A. Bell is a Professor of Computing and the Head of the School

Alfons Schuster has been a PhD student in the School of Infor-
mation and Software Engineering at the University of Ulster since
of Information and Software Engineering at the University of Ulster.
He received a BSc in Mathematics, 1969, MSc in Computer Science,
1976, and PhD in Computer Science, 1983, from the Queen’s Univer-
sity of Belfast. His current research interests include multi-media,
distributed databases, and linking reasoning under uncertainty with
established database work.