IADIS International Conference WWW/Internet 2007

IMPLEMENTING CONTEXT-SPECIFIC VIEWS TO DISTRIBUTED (RULE) DATABASES WITH FUZZY LOGIC

Ossi Nyknen
Tampere University of Technology, Department of Mathematics Korkeakoulunkatu 1, P.O.Box 553, FI-33101 Tampere, Finland

ABSTRACT In this article, we report a system for working with distributed fuzzy logic and rule systems, based on a mapping to logic programming with easily accessible Prolog tools. In short, we outline an approach for performing joins of fuzzy databases and procedures in terms of type-1 fuzzy logic programs, and generalize this approach by considering contextaware logic programs. The main use cases include aggregating fuzzy descriptions and managing distributed procedures that can be seamlessly integrated to context-aware logic programs, for implementing views to the global knowledge base. The main contribution of this article lies in the novel approach of expressing joins of fuzzy databases and fuzzy inference systems in terms of the logic programming paradigm, generalizing this framework in terms of explicit assertion and interpretation context(s), and then reducing these systems into Prolog programs. To illustrate our work, we discuss the approach in terms of simple examples, drawn from concrete applications, and discuss the implications. The motivation for the work stems from a European network of excellence thriving to establish a distributed open knowledge system based on the ideology of open source communities. KEYWORDS Fuzzy logic, Logic programming, Context-aware programming, Fuzzy join.

1. INTRODUCTION
Fuzzy logic provides a framework for modeling information systems in terms of vagueness (see, e.g., (Mendel 2001)). In brief, vagueness is captured by assigning logical statements fuzzy models, e.g., fuzzy membership values or entire fuzzy sets. Various fuzzy systems provide theories for deducing and querying derived information, often benefiting from the use of the expressions of a natural language, modeled as linguistic variables (see, e.g., (Turunen 1999)). A typical case is asserting that an individual belongs to a certain class (only) up to a certain membership degree. For instance, an article might be classified "somewhat technical" by an author. Relatively straightforward generalizations include capturing information in terms of fuzzy relations, and fuzzy rules. To date, there exist implementations of, e.g., fuzzy SQL systems that provide the functionality of performing fuzzy queries by extending the SQL systems with simple compatibility templates (e.g. select * from books where technicality is high). However, these are typically based on restricted scalar truth values, the tool support for fuzzy query seems relatively poor, and posing queries across multiple tables is difficult or impossible due to the lack of a definition of an established fuzzy join (Cox 2005). In this article, we consider an approach of encoding fuzzy databases and rule systems in terms of the socalled type-1 fuzzy logic programs. In particular, we point out an approach for defining a fuzzy join of tables of a fuzzy logic database. Our notion of fuzzy join demonstrates a special case of integrating fuzzy procedures in general (i.e. systems of interacting rules and facts). This approach escapes the apparent problem of seamless interaction between different rule systems in fuzzy control, which usually lack, e.g. variable terms (see, e.g., (Jang & Sun 1997), and generalizes in the spirit of logic programming (see, e.g., (Sterling & Shapiro 1994)). Finally, we extend the notion of fuzzy join by considering context-aware fuzzy logic programs. This approach provides an implementation of the notion of contextual views to (distributed)

305

ISBN: 978-972-8924-44-7 2007 IADIS

fuzzy logic programs that is important in massively distributed Internet applications. (For instance, the term "technical" might mean different things for a social scientist, a computer scientist, and a natural scientist.) This applied work is based on certain results described in detail elsewhere (Nyknen 2006; Nyknen 2007). For convenience of the reader, we aim informally reproducing the main concepts of type-1 fuzzy logic programs. It is worth emphasizing that the syntax of pure type-1 fuzzy logic programs is mainly needed for the sake of theory; practical implementations are by default written for suitable concrete Prolog interpreters. The main motivation for the development of the methods and the central use case of distributed contextsensitive classifications stem from the research needs of a large European Network of Excellence Project OPAALS (Open Philosophies for Associative Autopoietic Digital Ecosystems; see http://www.opaals.org/) coordinated by London School of Economics and Political Science. The overall objectives of the OPAALS project are to build a sustainable interdisciplinary research community in the emerging area of Digital Ecosystems (DE, http://www.digital-ecosystems.org/) and to develop an integrated theoretical foundation for DE research. The initial part of the (ongoing) project is focused on building the necessary processes and Open Knowledge Space (OKS) to support the interdisciplinary research activities in the spirit of open knowledge. Our work has been supported by the European Comission (IST network of excellence project OPAALS of the sixth framework program, contract number: FP6-034824). For purposes of this article, the OKS could be approximated as a repository and a model used to capture and manage community knowledge, integrating open source and evolutionary principles. In this framework, it becomes pivotally interesting to consider means for logically modeling rules and queries with respect to context-specific semantic descriptions, asserted by the scientific partners of three distinguished domains: social science, computer science, and natural science. In this article, we demonstrate using these three dimensions as a rudimentary notion for context(s). Ultimately, a set of interdisciplinary researchers seek means to successfully integrate the (orthogonal) aspects of rule-based and ontology-based knowledge engineering in the project. Eventually, this research stand is anticipated to provide an interesting amalgam of, e.g., OWL and logic programming applications. (Within the scope of this article, we limit the discussion to a restricted set of logic programming tasks, thus only dealing with a fraction of the projected OKS content.) The rest of this article is organized as follows: Section 2 describes the technique of fuzzy joins by first pointing out a crisp formulation with logic programming and then generalizing the solution in terms of type-1 fuzzy logic programs. Section 3 considers the case of asserting classifications with varying context and outlines a concrete use case for the technique with implications to contextual fuzzy logic programming in general. Section 4 finally concludes the article with technical remarks and discussion.

2. FUZZY JOINS WITH LOGIC PROGRAMMING

Consider the practical task of querying the following four (crisp) database tables:
table: pid joe ted sue table: pubid pub1 pub2 pub3 person technical yes no yes book title 'Formal logic' 'Programming logic' 'Java in a nutshell' table: pubid pub1 pub2 pub2 pub3 table: pubid pub1 pub2 pub3 topic keyword logic logic programming programming pubRating technical yes no no

In principle, this simple database might be used as a basis for making suggestions about recommended reading. (The table "book" is informative only; for simplicity, we will not use it in the examples.) In applications, the information of persons (pid, technical) and books (publid, title, keyword, pubRating) might originate from two different sources. However, please note that 1) the classification of persons or publications being technical is crisp, i.e. a person either is technical or is not; we shall extend categorization to encompass also vague or in-between classifications. Note also how 2) the interpretation of the property "technical" (at least with the given books) seems now to indicate "being technical in the

306

IADIS International Conference WWW/Internet 2007

mathematical sense" which seems to be valid only within a certain, shared context; we shall take this into account when considering context-aware logic programs. When the above modeling limitations (1, 2) can be accepted, working with the crisp database is simple. For instance, we may query this database to find the matching persons and publications in SQL as follows:
SELECT person.pid, pubRating.pubid FROM person pubRating.technical ORDER BY pubRating.pubid JOIN pubRating ON person.technical =

Alternatively, we may easily implement the whole system as a Prolog program (without the ordering). The main virtue of this approach is that it can be extended to manage both vagueness and context-specific interpretation. First, let us consider the following crisp implementation:
person_technical(joe, yes). person_technical(ted, no). person_technical(sue, yes). pubRating_technical(pub1, yes). pubRating_technical(pub2, no). pubRating_technical(pub3, no). topic_keyword(pub1, topic_keyword(pub2, topic_keyword(pub2, topic_keyword(pub3, logic). logic). programming). programming).

book_title(pub1, 'Formal logic'). book_title(pub2, 'Programming logic'). book_title(pub3, 'Java in a nutshell').

Please note that we are not technically using, e.g., the concept of units since we aim for maximal Prolog tool support. Note also that by combining (external) information we may use the given procedures to establish interesting new rules, for instance, knowing peoples' interests, we might assert: recommended(PERSON, PUB) :- interested(PERSON, KEYW), topic_keyword(PUB, KEYW). In Prolog, we may perform the query of the previous SQL example as follows: ?- person_technical(X,_Y),
pubRating_technical(Z, _Y).

Let us then consider the interesting case when the classifications can not be crisply categorized. This might take place when the categories are compiled according to heuristic evaluation or statistical induction. We may try to capture the vagueness of the clauses by assigning each goal a neutral fuzzy model mij that generalizes the crisp yes/no classification scheme. By a neutral fuzzy model m we mean a fuzzy set m = { (x, m(x) | x [0,1], m:[0,1] [0,1] } the concept is useful since it easily yields a system with matching, contextually aggregatable fuzzy models that are subject to various kinds of (linguistic) hedge operators. We may model the fuzzified setting with a type-1 fuzzy logic program (ignore the book title for brevity):
person_technical(joe)~m11. person_technical(ted)~m12. person_technical(sue)~m13. pubRating_technical(pub1)~m21. pubRating_technical(pub2)~m22. pubRating_technical(pub3)~m23. topic_keyword(pub1, topic_keyword(pub2, topic_keyword(pub2, topic_keyword(pub3, logic)~m31. logic)~m32. programming)~m33. programming)~m34.

The program is again very simple. The clauses are solely facts recording particular information of individuals. It is nevertheless interesting to consider performing a fuzzy join based on the level of the evaluated "technicality". This can be done e.g. by introducing a fuzzy rule that includes a fuzzy model instantiation operator (=~) and a fuzzy matching functor (match): appropriateTechnicality(PID,
PUB)~very :- A =~ person_technical(PID), B =~ pubRating_technical(PUB), match(A, B)~full. With this technique, the model assigned to appropriateTechnicality can be used for joining fuzzy properties assigned individuals {joe, ted, sue} and {pub1, pub2, pub3}.

It is important to observe that by default, fuzzy procedures might be integrated simply by applying them as goals. This provides the basic technique for composing compound fuzzy logic programs with references to "external" procedures (we will return to this topic in the end of this section). However, fuzzy model instantiation is required when computation with models is required, as above in the case of a fuzzy join. Intuitively, the above rule states that when the technicality of a person and a publication match well, then the level of the technicality of the publication is very appropriate for that person. Note that the rule does not directly say what is not appropriate by technicality level. Additional rules might be needed for the procedure for capturing this (rule) information. In any case, we must be careful that we do not equate "not having information" with "being false" etc. since this leads into difficulties of interpreting empty models. We may implement the above type-1 fuzzy logic program in Prolog as follows:

307

ISBN: 978-972-8924-44-7 2007 IADIS

person_technical(joe, m11). person_technical(ted, m12). person_technical(sue, m13). pubRating_technical(pub1, m21). pubRating_technical(pub2, m22). pubRating_technical(pub3, m23).

topic_keyword(pub1, topic_keyword(pub2, topic_keyword(pub2, topic_keyword(pub3,

logic, m31). logic, m32). programming, m33). programming, m34).

match(A, B, M) :- M = f(A, B).

appropriateTechnicality(PID, PUB, M0) :- person_technical(PID, A), pubRating_technical(PUB, B), match(A, B, M1), M0 = [very, [[M1, full]] ].

The above program is subject to the following query: ?The query returns:
PID M = PID M = PID M = PID M = PID M = = joe PUB = pub1 [very, [[f(m11, m21), = joe PUB = pub2 [very, [[f(m11, m22), = joe PUB = pub3 [very, [[f(m11, m23), = ted PUB = pub1 [very, [[f(m12, m21), = ted PUB = pub2 [very, [[f(m12, m22), full]]] ; full]]] ; full]]] ; full]]] ; full]]] ; PID M = PID M = PID M = PID M = No

appropriateTechnicality(PID, PUB, M).

= ted PUB = pub3 [very, [[f(m12, m23), = sue PUB = pub1 [very, [[f(m13, m21), = sue PUB = pub2 [very, [[f(m13, m22), = sue PUB = pub3 [very, [[f(m13, m23),

full]]] ; full]]] ; full]]] ; full]]] ;

The interpretation now depends upon the modeling of the referenced fuzzy models and the choice of few parameters of the fuzzy system. Further, the algebraic parse trees of the deducted fuzzy models need evaluation. Note that the number of the deduced facts is typically very high. Separating the evaluation of fuzzy models from the query computation enables reusing the already computed results in the case when only the models have changed since the last computation. We define the deduced fuzzy models recursively as follows (see (Nyknen 2007)): (k (Akr, Mk) ) Mr. With suitable parameters, this definition implements a Mamdani fuzzy reasoning system (see, e.g., (Jang & Sun 1997)). For instance, according to this definition, the structure [very, [[f(m11, m21), full]]] gets evaluated according to the formula ((f(m11, m21), full))very. Perhaps the most simple approach of selecting the parameters is choosing f = (i.e. fuzzy minima) and = (multiplication by a real number). The operator denotes the firing strength of two matching fuzzy sets. The remaining task is now choosing the fuzzy models for the program (for instance, set full = { (x, 1) | x [0,1] }; we will return to fuzzy modeling later with another example). Often in applications, the resulting fuzzy models need also defuzzification in the end, e.g., in terms of computing the centre of gravity. Note that in the case of neutral fuzzy sets, defuzzification might output a pair of numbers, i.e. a degree of association (or membership degree) and coupling (or significance). Should be logic program include overlapping facts or rules, the construction of type-1 fuzzy logic programs ensures that the yielded fuzzy models are well-defined. In short, the well-definedness of this construction is ensured by the Fact Canonisation Lemma and the Linear Aggregation Theorem of type-1 fuzzy logic programs (Nyknen 2007). As a consequence, since the order of (fact/rule) evaluations does not affect the (canonical) meaning of the deduced facts, we may simply aggregate the fuzzy models of the resulting overlapping facts for a complete evaluation. The logic programming paradigm provides a clear and a well-established method for integrating various sources of logical information. This approach also by default generalizes into accessing data published from one program unit (or a table or a procedure) in other program units (or tables or procedures). For instance, consider the rule recommended/2 above. When fuzzy models are available, we may implement it as follows: this rule asserts that a publication is a very recommended to a person if it contains a strong association with the keywords the person is at least moderately interested in. Note how the expression "at least moderately" (AL_moderately) involves operating an existing fuzzy model "moderately" with the "at least" hedge. Note also how this rule is simpler than the rule appropriateTechnicality since it does not involve comparing models of two facts, only matching them with the model constants associated with the goals of the rule. We might, however, use the rule appropriateTechnicality to refine the rule recommended to recommend only publications that are
recommended(PERSON, PUB)~very :topic_keyword(PUB, KEYW)~very. Intuitively, interested(PERSON, KEYW)~ AL_moderately,

308

IADIS International Conference WWW/Internet 2007

appropriate for a person:

AL_moderately,

recommended(PERSON, topic_keyword(PUB, KEYW)~very,

PUB)~very :interested(PERSON, KEYW)~ appropriateTechnicality(PERSON, PUB)~very.

Again, we might wish to assert additional rules for this procedure.

3. CONTEXT-AWARE LOGIC PROGRAMS

In a large, distributed system, asserting (fuzzy) clauses suffers from local modeling. This is particularly the case in making heuristic classifications since people of different social groups may sometimes perceive, e.g., (similar) terms differently. A practical problem related to the previous examples is that they assume a global interpretation of the terms and the classifications. This might not be acceptable in all applications. We may establish the notion of context-aware type-1 fuzzy logic programs as follows. Let {Pi} denote a set of (type-1) fuzzy logic programs. When programs are perceived as sets of clauses, we may construct new logic programs simply by aggregating the existing logic programs, P = Pi. Further, each unit, itself a logic program Pi (perhaps read from an external data source), can be associated with a formal context c(Pi) = ci. Contexts are needed for computing distances (or similarities) of the interpretation context c0 and the assertion context(s) ci, i>0. A fundamental technique for establishing a contextual view to the aggregated logic program is selection, i.e., including only certain program units {Pk} {Pi}. A more refined approach is to consider weights for each unit (and perhaps for each procedure) separately. Thus, a reasonable requirement for computing contexts is that the base set of contexts and the distance function (C, d) establish a meaningful pseudometric space. We usually require at least that for each x and y: d(x, x) = 0, d(x, y) 0, d(x, y) 1, and d(x, y) = d(y, x). These assumptions pose requirements for the technical design of the contexts. In particular, all participating contexts must be compatible with the pseudometric space used for computing the distances. (Or, alternatively, the distance function must be generic enough to handle "typical" context declarations this is the reason why the requirement of a genuine metric space is sometimes too restrictive.) After computing the distances between the assertion contexts ci and the interpretation context c0, i = d(c0, ci), we may define a weighted modular logic program P as P = (1-i) Pi. We interpret kPk so that it denotes a set of clauses which is obtained by multiplying the fuzzy models of the heads of the clauses in Pk by k. (If Pk is impure, i.e. includes crisp clauses with no associated fuzzy models, we add appropriate default true fuzzy models, multiplied with k.) We may think that the interpretation of the assertion contexts identifies a (local) contextual view to the (global) logic program. Let us then consider a simple but concrete example. Assume a group of authors {si} publishing and semantically annotating scientific articles for the benefit of the others. For simplicity, assume that the context of each author may be described as a point in the base set C' = [0, 1] 3 3. To come up with a suitable pseudometric space, associate this with distance || y - x || / 3 where |||| stands for the Euclidean norm (associate this with the name e3d). Clearly, this definition satisfies the conditions introduced earlier. Other metrics might be applicable as well. Intuitively, the co-ordinates of each ci C' now represent the authors association of three scientific domains: social science, computer science, and natural science. For instance, a context (1, 0.1, 0.5) intuitively implies strong association with social science, weak association with computer science, and medium association with natural science. (Of course, this simple formalized notion of context is clearly not subtle enough to recognize all the conceivable differences between the contexts of the real world.) Then, consider then the case of contextually aggregating two logic programs that describe semantic annotations for four articles using three semantic labels (languages, technology, and applications):
% Logic program P1: category(pub1, languages)~m41. category(pub2, technology)~m42. assertion_context(e3d, 1, 0.1, 0.5). % Logic program P2: category(pub2, technology)~m51. category(pub3, languages)~m52. category(pub4, applications)~m53. assertion_context(e3d, 0.1, 1, 0.2).

Of course, several different suitable designs exist for representing the intended information. Again, the symbols m41, m42, m51, m52, and m53 stand for type-1 fuzzy models. These are used for declaring the fuzzy membership for an individual to belong to a specific category. For simplicity, we may again assume that they are neutral fuzzy sets.

309

ISBN: 978-972-8924-44-7 2007 IADIS

Note that for the sake of clarity, we have again selected short and illustrative names for the individuals (pub1, category, languages, pub2, etc.). In a concrete application, it might make sense to identify individuals with global URI names (e.g. 'http://www.foo.org/archives/2007/pub1/' etc.). Note also that the both programs assert a classification for the article pub2. Now, assume an interpretation context of computer science c0 = (0,1,0). We get 1 = || (0,1,0) - (1, 0.1, 0.5) || 0.83 and 2 0.13. In other words, when compared to c1, the context c2 is closer to or more similar with c0. Intuitively, it thus makes sense to emphasize or favor the classifications of P2 when interpreting the global logic program. We may, e.g., think that this is due to the fact that the use of language in P2 is semantically closer to the interpreting agent than in P1. (Alternatively, this might also be interpreted as an implication of evaluated significance or even trust.) Note that in a concrete application with many authors, there would typically be many overlapping classifications with varying similarity of the assertion contexts which increases the usefulness of this design stance. As a result, we get the following weighted modular logic program (assertion contexts removed for simplicity):
category(pub1, languages)~e11. category(pub2, technology)~e12. category(pub2, technology)~e21. category(pub3, languages)~e22. category(pub4, applications)~e23.

where eab = (1 - a ) mab. Implementing this program in Prolog goes as before. Now, assume we would like to find out the articles annotated which the category "technology" with a query: ?- category(X, technology, M). We get X = pub2 M = e12 ; X = pub2 M = e21 ; No. In other words, the fuzzy model associated with the fact that pub2 belongs to the category "technology" is the aggregation e12 e21 = max(e12, e21). Since e12 = (1 - 1) m12, e21 = (1 - 2) m21, and 1 > 2, the aggregated model "depends more" on m21 than on m12. From applications' perspective, semantic interpretation obviously depends upon the fuzzy modeling. Let (x; a1, b1, a2, b2) denote a trapezoidial function of four parameters (see, e.g., (Jang & Sun 1997)). Assuming m12 = (x; 0.7, 0, 1, 1) and m21 = (x; 0.9, 0, 1, 1), we get e12 e 21 (1 - 0.83) (x; 0.7, 0, 1, 1) (1 - 0.13) (x; 0.9, 0, 1, 1). Of course, other kinds of fuzzy models are applicable as well. (A minimal requirement is that the representation language of fuzzy models is closed under the operators of union and multiplication by a real number.) Finally, since the above "folksonomy" example is intuitively relatively straightforward, introducing contextual logic programming for solely purposes of semantic tagging might seem like overkill. The potential of the approach should become more apparent when considering aggregating rules. Suppose the following simple rule is added to the program P1: category(X, applications)~very_high :category(X, languages)~ very_high, category(X, technology)~ very_high. Intuitively, this rule asserts that whenever something belongs to the categories "languages" and "technology" with a very high membership degree, this information suffices formally deducing that it also belongs to the category of "applications" with a very high membership degree. Note again that the rule does not say much about the universe of discourse when the body of the rule does not hold. However, additional rules might be asserted to capture this modeling stance. Nevertheless, the significance of this rule should vary upon context, etc. The presented approach generalizes into asserting more complex units. In particular, it is possible to aggregate units including overlapping rules. The utility of this work becomes more evident when large databases are available. For instance, one may search for resources "about logic languages that are not too technical" (etc.) within a given interpretation context. Besides fuzzification of the domain, the approach provides a technical mean for simplifying the underlying terminology with linguistic expressions, effectively providing the option of replacing the system design terms with a smaller set of suitable end-user terms.

4. CONCLUSION
In this article, we have reported a system for working with distributed fuzzy logic and rule systems, based on a mapping to logic programming with easily accessible Prolog tools. In short, we have outlined an approach for performing joins of fuzzy databases and procedures in terms of type-1 fuzzy logic programs, and

310

IADIS International Conference WWW/Internet 2007

generalized this approach by considering context-aware logic programs. We will conclude the article with notes about our target application and the related technical issues. First, it is worth noting that while description of the exact applications is out of scope of this article, the information of the examples is actually available in the OPAALS project. In particular, each research unit has been classified with respect to three scientific domains: social science, computer science, and natural science, and researchers have explicitly expressed their areas of interest in terms of project or domain-specific keywords, using which also actual research work can be described. Second, from the engineering point of view, applications involving distributed context-sensitive logic programs need to agree upon a format of communication. In the OKS context, a reasonable assumption is that communication takes place in terms of published Semantic Web (SW) resources whose syntax is known (about SW core technologies, see, e.g., (Herman, 2007)). We may thus assume that each data source i is captured as a Web resource with a URL name, with a representation r(Pi). Further, assume each data source i originates from a context ci. The engineering task is now the following: retrieve information about the available representations, transform the (currently accessible) set of clauses of r(Pi) into the clauses of the type-1 fuzzy logic programs Pi, 3. recognize the assertion and the interpretation context(s) and compute the distances i, and 4. compile a Prolog program with an established system for posing queries (interfacing with the application-specific program logic). The first step depends upon system architecture. In a system without a strict centralized design, it can in principle be accomplished with a peer-to-peer network with RSS feeds including the suitable descriptions. The step 2 involves technical pre-processing for normalizing the representation of the rule content. It may be trivial (the representation is already suitable), extremely difficult (the fundamental modeling and the logical concepts of the representation need heuristic evaluation), or something in between (a mechanical transformation). Assuming the representations are XML formats, the step 2 can be (at least conceptually) accomplished, e.g., with a GRDDL processor (Gleaning Resource Descriptions from Dialects of Languages). The step 3 may require similar processing but instead of a set of clauses, it eventually outputs real numbers. When compiling legacy data, identifying the assertion context may include applications of automated classification algorithms. Finally, the step 4 involves utilizing a Prolog interpreter than can be integrated with the target application. We have experimented mainly with WSI-Prolog and tuProlog (see (Wielemaker 2007; aliCE 2007)); other frameworks are of course applicable as well. Few observations are in order: 1. The mechanical fuzzy logic programming framework provides a necessary technical component for working with distributed descriptions. However, it alone is not sufficient. Fuzzy modeling involves design decisions, justification of which depends also of, e.g., social factors of the community. Further, as usual, the motivation of asserting metadata stems from the utility of the applications. 2. Some of the information sources i may be (temporarily) unavailable. While this will surely have an effect, overlapping sources may suffice in reproducing a decent view to the logic program. When the system of overlapping clauses is sufficiently large, we may statistically estimate this effect, e.g., assuming that the sets of fuzzy models are normally distributed. Assuming an upper limit for the number of the clauses of the information sources can be reasonable approximated, these estimates may also be used to incrementally evaluate the expected correctness of the so far drawn conclusions (e.g. when accessing the representations takes a long time due to slow networking connections or heavy computational load of the services). 3. The system may include fuzziness due to lack of information (e.g. fuzzy models are due to statistical induction with fundamental imprecision, or users misinterpret the meaning of certain terms), fuzziness due to the use of linguistic expressions (e.g. because of using a restricted set of linguistic variables), and fuzziness due to the (un)availability of network resources (as above). 4. From applications' perspective, the interpretation context should be perceived as a parameter of the query process. Besides automatic recognition of the (default) interpretation context, experienced endusers might wish to explicitly modify the assertion and interpretation contexts, in order to explore the potential views to the logic program. This is particularly the case when the interpretation context needs to be refined to exclude unwanted or harmful classifications or program units from the view. 1. 2.

311

ISBN: 978-972-8924-44-7 2007 IADIS

While this process can not be completely mechanized, heuristic design support might be provided in cases when some proportion of clauses gets assigned nearly empty of full models. 5. While the system deals with fuzzy classifications, it is (for now) assumed that the names of the individuals and classes are effectively crisp (e.g. by default, pub1 and pub1 are assumed to be different entities). Logical pre-processing might be required to ensure this fact, e.g., by semantically bridging the logical synonyms (e.g. wither with OWL DL predicates (owl:sameAs), or with meta predicates of logic programming: "foo(X) :- sameAs(X,Y), foo(Y)." etc.). In some cases, this requirement can be relaxed by adding a layer of interpretation dealing with fuzzy names with respect to a suitable system of base names. 6. Since a standard for Web rules languages is not yet available (see, e.g., (Hawke 2007; Stamou & Pan. 2007; Laskey et al. 2007)), an ad hoc representation for the rules and type-1 models is needed. Further, it makes sense to limit the choice of the membership functions of the fuzzy models in clauses, in order to simplify the computation of, e.g., points of gravity, and for efficient representation of fuzzy models (see, e.g., the Intrinsic Imprecision Lemma in (Nyknen 2007)). 7. A distributed fuzzy logic program will face evolution on many levels. While fuzzy queries manage, e.g., a slow shift of terminology, this evolution is not explicitly modeled by the current system. The last point is particularly important in large-scale systems with a long lifetime. It would seem that managing evolution requires at least capturing version information of individuals and classes, and introducing related system logic to the setting. It is worth noticing that while this issue could be to certain extend resolved simply by refining the notion of context, it in practice deserves the status of a research question of its own. It also suggests that context bears internal structure which benefits from applicationspecific design.

REFERENCES
aliCE, 2007. tuProlog home. DEIS, University of Bologna at Cesena. Available at http://www.alice.unibo.it/tuProlog/. Cox, E. 2005. Fuzzy Modeling and Genetic Algorithms for Data Mining and Exploration. Elsevier, USA. Hawke, S. 2007. (Ed.) Rule Interchange Format Working Group Charter. W3C. Available at http://www.w3.org/2005/rules/wg/charter.html. Herman, I. 2007. (Ed.) W3C Semantic Web Activity. W3C. Available at http://www.w3.org/2005/rules/wg/charter.html. Jang, J-S.R. & Sun, E.M., 1997. Neuro-Fuzzy and Soft Computing: A Computational Approach to Learning and Machine Intelligence. Prentice Hall, USA. Laskey, K., Laskey, K. & Costa, P. 2007. (Eds.) Uncertainty Reasoning for the World Wide Web Incubator Group Charter. W3C. Available at http://www.w3.org/2005/Incubator/urw3/charter. Mendel, J. M. 2001. Uncertain Rule-Based Logic Systems: Introduction and New Directions. Prentice Hall, USA. Nyknen, O. 2007. Knowledge Agents via Logic Programming and Fuzzy Reasoning. Doctoral Thesis, Tampere University of Technology, Publication 655, ISBN 978-952-15-1727-3. Introduction and synthesis available at http://webhotel.tut.fi/library/tutdiss/show.php?id=113. Nyknen, O. 2006. An Approach to Logic Programming with Type-1 Fuzzy Models Using Prolog. Proceedings of the IADIS International Conference of Applied Computing. San Sebastian, Spain, pp. 201-208. Stamou, G. & Pan, J. 2007 (Eds.) Uncertainty in RuleML rulebases (FuzzyRuleML). W3C. Available at http://www.image.ece.ntua.gr/FuzzyRuleML/index.html Sterling, L. & Shapiro, E. 1994. The Art of Prolog: Advanced Programming Techniques. MIT Press, USA. Turunen, E., 1999. Mathematics Behind Fuzzy Logic. Physica-Verlag Heidelberg, Germany. Wielemaker, J. 2007. SWI-Prolog's home. HCS, Informatics Institute of the University of Amsterdam. Available at http://www.swi-prolog.org/.

312