Logic-Based Representation and Reasoning for User Modeling Shell Systems

User Modeling and User-Adapted Interaction9: 217–282, 1999.© 1999Kluwer Academic Publishers. Printed in the Netherlands.

217

Logic-Based Representation and Reasoning forUser Modeling Shell Systems?

WOLFGANG POHLGMD FIT.MMK, Schloss Birlinghoven, 53754 St. Augustin, Germany.e-mail: [email protected]

(Received 3 January 1998; accepted in revised form 14 May 1998)

Abstract. Core services of user modeling shell systems include the provision of representationsfor user model contents and for other relevant knowledge, and of reasoning mechanisms. Theserepresentation and reasoning facilities should be powerful and flexible, in order to satisfy bothcomplex and specialized needs that developers of user modeling systems may have. This article firstidentifies these needs through a comprehensive overview of logic-based representation and reasoningin user modeling system. Then, theAsTRa (Assumption Type Representation) framework for logic-based user model representation and reasoning is presented. This framework obtains its power andflexibility through an integration of the two main scientific approaches that were pursued to date,namely the partition approach and the modal logic approach. The central notion of the framework isthe ‘assumption type’, a partition-like partial knowledge base for storing all assumptions about theuser that are of the same type. Within assumption types, logic-based representation formalisms can beemployed. The semantics of assumption types and content formalisms can be characterized in termsof modal logic, so that an extension to full modal logic is possible. Moreover, special mechanisms forhandling so-called ‘negative assumptions’ are developed, which are also firmly grounded in modallogic semantics. The paper concludes with a description of the user modeling shell BGP-MS as aprototypical implementation ofAsTRa, and a discussion of the approach in the light of other usermodeling shells.

Key words: Modal logic approach, partition approach, user model representation and reasoning, usermodeling shell systems.

1. Introduction

In about twenty years of user modeling research, many different user modelingtechniques and mechanisms have been developed. However, a common set of usermodeling tasks has evolved that almost any user modeling system must be able tocarry out. User modeling systems need mechanisms that (cf. Kobsa & Pohl, 1995)

– form assumptions about users based on their interactions with the computersystem,

– represent and store these assumptions in a knowledge base,

? The managing editor of this paper was Diane Litman.

218 WOLFGANG POHL

– infer additional assumptions from given assumptions,– deal with inconsistencies between assumptions, and– supply the system with information about current assumptions.

The development of such mechanisms can be quite costly. Therefore, consid-erable effort was spent in building application-independentuser modeling shellsystems, which provide implementations of application-independent user modelingmechanisms to the developers of user modeling systems (Finin, 1989; Brajnik &Tasso, 1994; Ikeda & Mizoguchi, 1994; Kobsa & Pohl, 1995; Kay, 1995; Orwant,1995; Paiva & Self, 1995). At the core of every user modeling system there isa mechanism for representing and for reasoning about the assumptions that areheld about a user. Therefore, every user modeling shell should offer representationand reasoning facilities which can meet the needs of as many systems as pos-sible.

Our primary goal was to develop application-independent representation andreasoning mechanisms that are suitable for a wide range of user modeling applic-ations and hence appropriate for implementation in user modeling shell systems.As a result, we will present a generic representation and reasoning framework thatattempts to meet these demands by combining power and flexibility. The main ideabehind this framework is that a shell system should provide a variety of representa-tion and reasoning techniques from which a user modeling application can choose,according to its specific needs. In addition, the available methods should be usablein an integrated fashion by applications with complex demands and, hence, theneed for a powerful representation and reasoning system.

The resulting representation and reasoning framework is based on a long tradi-tion of employing logic-based mechanisms in user modeling. It was significantlyinfluenced by the experiences that the author gained from the development of theuser modeling shell system BGP-MS (Kobsa & Pohl, 1995) and from the use ofBGP-MS with several applications. This system is representative of one of the twomain approaches to logic-based user modeling, namely of the partition approach.In this approach, representational power is achieved by allowing for partial know-ledge bases in a user model, so-called partitions, which can be used to distinguishdifferent kinds of user model contents. The most important competitor to the par-tition approach is the modal logic approach, which claims that the representationand reasoning capabilities of modal logic sufficiently cover user modeling needs.Our framework combines both approaches. It uses a formally specified, partition-like approach as its basic component. This can be characterized in terms of modallogic, so that modal logic mechanisms can be added to and integrated within thebasic facilities in such a way that the full power of modal logic is available and thebasic elements can be used flexibly.

In the next section, we will deal with the basic issues of our work. We willdiscuss assumptions about the user, which are central to every user model, andintroduce theassumption typeas a characteristic component of an assumption.Furthermore, the partition approach and the modal logic approach as the two main

REPRESENTATION AND REASONING FOR USER MODELING SHELL SYSTEMS 219

approaches to representing assumption type information in user modeling systemsare compared, and a new way of integrating both paradigms is presented. Sections 3and 4 offer comprehensive reviews of the user modeling literature concerninglogic-based representation and reasoning, respectively. From these reviews, wederive the design principles of our representation and reasoning framework, presen-ted in Section 5. It is calledAsTRa (Assumption Type Representation), becauseits central concept is the assumption type, which is technically interpreted as apartition-like partial knowledge base. This and other basic ideas ofAsTRa havealready been touched on in a previous paper (Pohl & Höhle, 1997). In the presentpaper, we give a much more detailed and advanced presentation. TheAsTRa frame-work has been prototypically implemented into BGP-MS. In Section 7, we willshow how BGP-MS was modified to become anAsTRa system and give an ex-ample of the use ofAsTRa features in BGP-MS. In Section 7, we discuss theAsTRaframework comparing it to other user modeling shells and another related systemand reflecting upon the shortcomings of logic-based techniques in general.

2. Basic Issues

2.1. WHAT IS IN A (LOGIC-BASED) USER MODEL?

Before talking about general user model representation mechanisms that might beappropriate for user modeling shell systems, let us have a look at the typical con-tents of a user model. The following is a simple example of a user model content,concerning a user belief:

(It is assumed that) the user believes that sharks are dangerous.

The first approach to representing this user model content would be to formulate thewhole sentence (with or without the redundant phrase in parentheses) as a logicalexpression. However, if the user model were to contain assumptions about userbeliefs only, it would be sufficient to have an expression for

Sharks are dangerous.

in the user model in order to represent the first sentence.Many user modeling systems follow the latter approach. It differs from the first

one in that theassumption type(in the example: assumption about the beliefsof the user) is not represented in the logical expression. Instead, the user modelis seen as a container for assumptions of one kind and is used to store theas-sumption contentonly. Particularly if only one assumption type is to be modeled,the container approach will obviously avoid redundancy and allow the use of aless complex representation system. If the user model consists of assumptions ofdifferent types, several containers, one for each type, can be employed. Then, ofcourse, it is necessary to label the containers so that assumption type information

220 WOLFGANG POHL

is not lost. The necessary precondition for employing containers, also called partialknowledge bases orpartitions (see next section), is that an assumption about theuser can be split up into assumption type and content, i.e., it can be written as

assumption type:assumption content

The example given above can be written as

assumption about user beliefs: sharks are dangerous

The distinction between assumption type and assumption content will be im-portant throughout this paper. The aboveAT : ac notation for user model contentswith assumption typeAT and assumption contentac will be used frequently. Suchexpressions will be referred to asassumption type expressionsor type-internalexpressions. In the next section, we will discuss possible assumption types.

2.2. TYPES OFASSUMPTIONSABOUT THE USER

The representation component of a user modeling shell system should be generalenough to permit the representation of a wide range of assumptions about the user(the genuine user model) as well as domain knowledge and further user modelingknowledge including inference rules for user model acquisition. All of this know-ledge is maintained within a user modeling knowledge base (short: UMKB). Thissection deals with the types of assumptions that may occur in user models. Ideally,a user modeling shell will be able to deal with as many of these types as possibleand may additionally handle domain and other user modeling knowledge.

Reviews on user modeling (see, e.g., Kass & Finin, 1988; Wahlster & Kobsa,1989; and McTear, 1993), typically present lists of unrelated assumption types.These types include (system assumptions about the user’s) goals and plans, capabil-ities, preferences, knowledge and beliefs. But, particularly if beliefs are concerned,there can be more. Everything in a user model can be regarded as belief of theuser modeling system, so that there are two ‘believing agents’: user and system.Therefore, as is often the case with multi-agent scenarios, so-called ‘nested beliefs’(i.e., beliefs of one agent about the beliefs of another, etc.) are also considered inuser modeling.

For naming standard assumption types and nested types (complex types in termsof Kobsa, 1989) in a uniform way, we use a notation that follows Cohen (1978)and has been used in a similar way by other authors (Allen & Miller, 1991; Kobsa,1985; Kobsa, 1990; Kobsa & Pohl, 1995; Taylor et al., 1996). In this notation,assumption type labels consist of sequences of agent-modality pairs. In user mod-eling, the standard agents are S (the system) and U (the user), but other agents arealso possible. The most frequently used modality is B (for beliefs). In addition, W(for wants) is often employed to refer to the goals of agents. Other modalities arepossible, too, like Pref for preferences, I for interests, etc.


Using this scheme, SBUB denotes the class of assumptions (i.e., system beliefs)about user beliefs, and SBUW stands for assumptions about user goals. Assump-tion types involving nested beliefs are SBUBSBUB (assumptions about what theuser believes the system to assume about her beliefs) or SBUBSBUW (assumptionsabout what the user believes the system to assume about her goals). Since in usermodeling only system assumptions are considered, the first agent-modality pair insuch a label is always SB. This also holds for specific types of beliefs that theoretic-ally correspond to an infinite number of other belief types and are typically calledmutual beliefs. In theory, the set of system assumptions about mutual beliefs ofsystem and user (labeled SBMB) is the intersection of types SB, SBUB, SBUBSB,SBUBSBUB, etc. (Kobsa, 1990). Another mutual belief type is SBMBUB (mutualbeliefs about user beliefs). Of course, in practice only a finite number of types canbe handled explicitly. The developer of a user modeling system may make use of amutual belief type with a finite number of subtypes, thus giving a system-specific,pragmatic interpretation of mutuality.

The above notation does not support notions of uncertainty within assumptionsabout the user. For our discussion of user modeling systems in Section 3, we extendthe assumption type notation to cover, as we call it,graduated assumptionsaboutthe user. In principle, a graduation can involve both agents of the user modelingprocess, S and U, and can occur at any level of nesting of an assumption type.We will denote graduation with an asterisk (*). Let us take the basic assumptiontype SBUB as an example: If the strength of assumptions about user beliefs is tobe graduated, the corresponding assumption type is SB*UB. If assumptions aboutthe strength of user beliefs are to be made, then the corresponding type is SBUB*.SB*UB* assumptions are also possible; in this case, assumptions about strengthsof user beliefs are themselves graduated. An example is the Grundy system (Rich,1979), which uses numerical values to express both the (assumed) strengths of userpreferences and the certainty of the system about its assumptions. Thus, Grundyuses SB*UPref* assumptions.

If graduated types are considered, the notation for assumption type expressionsneeds to be extended to cope with the graduation (uncertainty, strength, confidence,. . . ) values that are used in many user modeling systems. We will use a list ofvalues after anAT : ac expression, with one value per∗ in the assumption type.For instance: A Grundy user may be assumed with a confidence rating of 900 totolerate violence in books to a degree that is coded by the number 5. Using ournotation, this assumption can be formulated as

SB*UPref* : tolerate-violence[900,5].The focus of this paper is on the use of logic-based techniques for user model rep-resentation and reasoning. Hence, in our proposal of a representation and reasoningframework, we will not deal with graduation. However, we would like to point outtwo things: First, as indicated by our notation above, logic-based representationscan be extended with graduations. And second, also with pure logic, it is possible

222 WOLFGANG POHL

to get three-valued graduation, namely by using negation within user modelingknowledge bases (UMKBs). Considering assumptions about user beliefs concern-ing the assumption contentp, the use of negation offers three degrees for SB*UBassumptions: 1. ‘the user believesp’ (SBUB:p) is in the UMKB; 2. ‘the user doesnot believep’ (which we denote by SB∼UB:p) is in the UMKB; and 3. neither ofthese is in the UMKB.1

2.3. POWERFUL AND FLEXIBLE USER MODEL REPRESENTATION

In the user modeling literature a large number of approaches to user model repres-entation have been presented. Many of them quite specifically serve the purposes ofthe underlying application. In these cases, specific representation languages withspecial semantics are used, and assumption type information usually is not rep-resented explicitly or mixed with content information. It is often difficult to relateand compare such approaches to representation mechanisms of other user modelingsystems. These specialized and often very simple representation approaches are notviable in a shell system. The representation formalism(s) offered by a shell musthave ‘open’ semantics, relying on general language constructs that can be useful todifferent applications. Such formalisms should permit the explicit representationof assumption type information so that applications which need to distinguishbetween assumptions of different types can be supported. In sum, representationformalisms for user modeling shells should be powerful enough to satisfy the needsof a range of user modeling systems.

As we have stated, the two main logic-based approaches to powerful user modelrepresentation are thepartition approachand themodal logic approach. Both ofthem provide means for explicitly representing assumption type information. Inthe following brief review of the two approaches, they will be found to be some-what complementary. Consequently, we propose a new way of integrating bothapproaches in order to combine their advantages. This proposal is the basis for therepresentation and reasoning framework presented in Section 5.

2.3.1. Partition Approach

In general, partitions offer the possibility to store knowledge or other items sep-arate from other knowledge; they can be regarded as partial knowledge bases.The partition approach fits our idea of assumption type expressionsAT : ac, whichsuggests that the two aspects of a user model entry can be separated; for everyassumption type, a partition can be used to store the contents of this type. Suchan approach was first employed by Cohen (1978) to extend semantic networksso that it became possible to distinguish different assumption types. Cohen uses

1 A fourth possibility is that both expressions are in the UMKB. This case, however, does notconstitute a fourth degree, since it is equivalent to case 3 in the sense that there is no informationabout the user believing or not believingp.


Figure 1. Partition-based and modal logic user model representation.

partitions as ‘spaces’ to collect knowledge items. Each space (i.e., partition) ischaracterized by a belief and goal nesting. E.g., an SB partition stores all items thatare considered system beliefs, SBUW contains system beliefs about what the userwants, etc. Partitions are nested, meaning that a knowledge base typically containsa ‘nesting hierarchy’ of partitions with SB as the outermost partition. Similar toCohen’s approach, Ballim discussed the use of nested partitions to represent beliefnestings regarding different agents (Ballim & Wilks, 1991; Ballim, 1992). Kobsa(1985) used partitions for representing user models in the system VIE-DPM, theuser modeling component of the natural language processing system VIE-LANG.In VIE-DPM, partitions are seen as contexts that contain beliefs or goals at onelevel of nesting. In this system, partitions do not contain inner partitions; theyare separate entities, which are however linked to other partitions that representa deeper nesting of beliefs and goals. Later, in an early paper on the user modelingshell system BGP-MS (Kobsa, 1990), Kobsa introduced inheritance hierarchiesof partitions. Partition inheritance makes it possible to store common or mutualbeliefs of dialog partners in distinct partitions, which pass on their contents toother partitions that store the beliefs of each partner. Essentially, this later partitionmechanism was retained in BGP-MS and has been used as basic means for theimplementation of the representation framework that is proposed in this paper.

By pursuing a separate representation of assumption type and assumption con-tent, the partition approach promises flexibility. In principle, several content form-alisms might be used within partitions, if there is a need for different kinds ofrepresentation for assumption contents. On the left side of Figure 1, there is apartition representation of the example from Section 2.1. The partition is namedSBUB to indicate that the assumption is about a user belief. Within the partition,a graphical representation like that of traditional KL-ONE formalisms is used torepresent the subsumption ‘sharks are dangerous’.

2.3.2. Modal Logic Approach

Modal logics enables one to introduce all kinds of operators to characterize pro-positions. In general, a necessity operator2 and a possibility operator3 are addedto standard propositional or predicate calculus.3 is often omitted, since the equi-

224 WOLFGANG POHL

valence (letφ denote an arbitrary formula of modal logic)3φ ≡ ¬2¬φ holds.If there is only one operator in a modal logic, it corresponds to2. In work onreasoning about knowledge and belief, the modal operator2 is often replaced byspecial operators likeB for belief orK for knowledge. Similarly, it is possible toreplace2 by non-epistemic operators likeW for ‘. . . is wanted’ (or ‘. . . is a goal’).Since all such operators are merely syntactic variants of the2 operator, they canbe written as parameterized2 operators, using notations like[B] or 2B . Often itis necessary to reason about several agents; in this case separate operators withagent indices, likeBA1, BA2, etc. can be used. Agents can be regarded as additionalparameters of the standard operator2, so that, e.g.,BA can be written as2(B,A).Hence, in this paper the generic modal operator is written as2(m,a), with m beingshort for ‘modality’, anda being short for ‘agent’.

Using this notation, various modalities or attitudes that are relevant to user mod-eling, such as goals, preferences, intentions etc. can be expressed. On the right sideof Figure 1, we see a modal logic expression that conveys the same meaning as thepartition representation on the left. The sequence of modal operators,2(B,S)2(B,U),corresponds to the partition label SBUB, and the nonmodal part of the formula,∀xshark(x)→ dangerous(x), represents the assumption content.

2(B,S)¬2(B,U) dangerous(dolphin21)

∀x 2(B,S)2(B,U) dangerous(x) → 2(B,S)2(W,U) attacks(flipper, x)

2(B,S)2(W,U) 8 ∧ 2(B,S)2(B,U) (8→ 9) → 2(B,S)2(W,U) 9Figure 2. Representational power of modal logic.

In general, modal formulas of the formM p, which consist of an operatorsequenceM and an operator-free partp, correspond to partition-based representa-tions. Figure 2 presents examples of modal logic formulas that go far beyond thisrestricted form and hence cannot be represented with partitions. The first formulaexpresses that the user is assumed not to believe that the object ‘dolphin21’ is‘dangerous’. Similar assumptions about what isnot believed, wanted, etc. willbe callednegative assumptionsfurther on. Standard partition mechanisms do notallow for negative assumptions. The second formula represents the rule that if theuser is assumed to believe that an object is dangerous, she can be assumed to wantthat it is attacked by ‘flipper’2. Partition mechanisms do not permit representa-tion of and reasoning with such type-external expressions, which can be used toformulate relationships between assumptions of different types. With modal logic,even general type-external relationships can be represented: The last example is amodal formula scheme, i.e., a generalized expression which, in this case, meansthat a user can be assumed to want the known implications of her goals. Together,

2 The domain of these and further examples will be explained in Section 6.5.


the examples in Figure 2 demonstrate that modal logic is much more expressivethan partition-based representation.

The exclusive use of modal logic in the area of user modeling was advocated byAllgayer et al. (1992). Hustadt (1994; 1995) presents an extension of descriptionlogics with modal operators, which can be parameterized with modality and agentlabels, thus obtaining a multi-modal, multi-agent logic for user modeling. In Sec-tion 3.2.2, this work and several other examples of the use of modal logic for usermodeling will be described.

2.3.3. Integration

With the examples in Figure 2, we have indicated that modal logic can satisfycomplex user model representation needs. Hence, a user modeling shell could of-fer modal logic as the only representation formalism. However, providing onlyone powerful formalism is disadvantageous for a shell system. User modelingapplications with special, but less complex demands would be forced to employa formalism which was not tailored to their needs. This might lead to unnaturalrepresentation and unnecessarily inefficient processing of knowledge.

A shell system can be more flexible if a partition approach is pursued. Forinstance, it can offer several representation formalisms for different kinds of as-sumption contents, e.g., KL-ONE for terminological knowledge (typically used inbelief partitions like SB and SBUB) and Prolog for describing user goals in SBUW.However, as we have noted, the expressiveness of a partition-based representationsystem may not satisfy complex user modeling needs. Furthermore, unlike modallogics, partition mechanisms do not have a clear semantics (Hustadt, 1995).

In sum, we have a trade-off: Modal logic lacks the simplicity and the potentialfor flexibility of the partition approach, while partition representation lacks the rep-resentational power and formal rigor of modal logic. Kobsa was the first to suggesta combination of modal logic and partitions for the user modeling shell systemBGP-MS (Kobsa, 1992). His proposal was based on the observation that partitionsand partition contents can be used to represent simple modal logic expressions.Hence, BGP-MS was made to accept modal logic expressions as input but to intern-ally represent them as partition contents if possible (Kobsa & Pohl, 1995). Withinpartitions, first-order predicate calculus was available to represent all possible as-sumption content information, but BGP-MS would always try to represent as manycontents as possible using a more specialized and more efficient terminologicalrepresentation formalism. That is, Kobsa proposed atop-downapproach to integ-rating partitions with modal logic: moving down from more complex formalismsto more specialized ones, while hiding these specialized facilities from the outsideview. Taking the example of Figure 1, in a top-down system the modal formulaon the right would have to be input; the system itself would produce the internalrepresentation using a terminological subsumption within partition SBUB.

In this paper, we suggest a different,bottom-upapproach of combining parti-tions with modal logic. Bottom-up means first that the basic parts of a combined

226 WOLFGANG POHL

system, namely partitions and partition contents, can be addressed directly. Second,modal logic is put on top of the basic parts to extend their expressive and reasoningpower,if desired. Let us look again at Figure 1: In a bottom-up system, the repres-entation on the left would be produced directly by specifying that a terminologicalsubsumption shall be contained in partition SBUB. This approach is especiallyuseful for shell systems: According to our experience using BGP-MS with severalapplications (Kobsa et al., 1994; Pohl et al., 1995a; Fink et al., 1996), shell systemusers (user model developers) tend to explicitly choose from the range of shell fa-cilities. Therefore, they should not be limited to have top-down access to availablerepresentations through one general and complex formalism only. In our bottom-up approach, the integration of partition representation and modal logic is basedon a modal logic semantics for the partition part, thus answering the criticisms ofproponents of the modal logic approach.

3. Representation

In this and the next section, we will review the literature for approaches to usermodel representation and reasoning, which can be regarded as logic-based or canbe related to logic-based approaches. The review first deals with user model repres-entation, covering standard logical formalisms: propositional calculus, first-orderpredicate calculus (FOPC), and modal logic. Specialized logic-based formalismsare also considered. Second, in the next section, user model reasoning issues arecovered, emphasizing logic-based deduction. From our review, we will inducethe requirements that a logic-based representation and reasoning system in a usermodeling shell should meet.

We have seen that assumptions about the user can be regarded as consisting oftwo main components, namely assumptiontype and assumptioncontent. In thissubsection, we will find that there are mainly two alternatives when using logicalformalisms for user modeling; either assumption type information is represented–or it is not.

In the first case, logical expressions denote both type and content information.This is in line with the modal logic approach. However, modal logic with its oper-ators for representing type information is not the only option. Several systems haveused FOPC while employing special predicates to represent type information.

In the second case, logical expressions denote assumption content only. Mostly,they are maintained in only one knowledge base; this implies that all assumptionsrepresented are of the same type. Only in a few systems of this kind have severalknowledge bases been used to distinguish assumptions of different types. But nomatter if only one or more knowledge bases are used: it is common to these systemsthat all assumptions within a knowledge base are of the same type. Hence thesesystems are basically in line with the partition approach.

We will present examples of both alternatives and discuss advantages and dis-advantages.


3.1. REPRESENTINGASSUMPTIONCONTENT ONLY

3.1.1. Propositional Calculus

Sentences like ‘snow is black’ that can be said to be true or false are the basic entit-ies of propositional calculus. Logical connectives like ‘and’, ’or’, etc. can be usedto form complex propositions. Propositions without connectives are theatomsofpropositional calculus. Note that objects and relationships between objects withina proposition (in the above sentence: the abstract entities ‘snow’ and ‘black’, andthe relation ‘to be’) cannot be represented in propositional calculus.

Quite a number of user modeling systems have used propositions or relatedformats for user model representation. The user model described in (Paris, 1989)contains assumptions regarding the user’s knowledge about objects, i.e. about theirfunctions and other properties, and his knowledge of basic concepts of the domain.This is represented by two lists of symbols, one for the objects and one for theconcepts the user knows. The type of assumption used here is SBUB, and theassumption content can be represented by atomic propositions. So, using the sug-gested notation for assumption type expressions, the symbol ‘microphone’ beingcontained in the list of known objects can be rewritten asSBUB:microphone3.

In contrast to the system of Paris (1989), most systems employ atomic pro-positions together with (symbolic or numeric) graduation values. This kind of usermodel representation has been called “linear parameters” in the literature (Wahlster& Kobsa, 1989, McTear, 1993). Several authors use SBUB* assumptions to dealwith the user’s degree of familiarity with concepts, instruments or other objectsof the underlying domain. A typical example is Nwana (1991), who associatesdomain concepts of a tutoring domain with one out of three graduation levels,denoted by the numbers 0 (not known), 1 (fairly known), and 2 (well known). It isinteresting to note that Nwana says his student model contains expressions of theform sm(concept, level_of_understanding) for any concept the associated value ofwhich is 1 or 2, these numbers being thelevel_of_understandingvalue. This seemsto indicate that simple FOPC expressions are used, but it is quite easy to detect thesyntactic sugar here. A user model content sm(concept, n) can be rewritten as agraduated assumption type expression with concept symbols (i.e., atomic proposi-tions) representing the assumption content:SBUB*:concept[n]. Similar examplesof using graduation values with representations equivalent to atomic propositionscan be found, e.g., in (Tattersall, 1992) and (Peter & Rösner, 1994).

Other user modeling systems have used graduated assumptions of type SB*UBin order to express the strength of system belief in its assumptions about userbeliefs. The system UMFE (Sleeman, 1985) presents an approach to user modelingthat may be generalized and used in other systems. In its user model, all elements ofa concept hierarchy (which is part of system domain knowledge) are assigned oneof the values ‘known’, ‘not-known’, and ‘no-information’. So, there are values forpositive, neutral and negative evidence about the user knowing a concept. Note that

3 We will henceforth use asans serif font for (partially) concrete assumption type expressions.

228 WOLFGANG POHL

this kind of graduation corresponds to what can be expressed with logical negation;UMFE’s user model could be represented using atomic propositions (denoting theconcepts) with assumption types SBUB and SB∼UB. Given a conceptC, ‘known’and ‘not-known’ would be replaced by havingSBUB:C andSB∼UB:C, respect-ively, in the user model. ‘No-information’ would, quite naturally, correspond toneither of these assumptions being contained in the user model.

An example of a system that uses more than one graduation with each usermodel content is Grundy, which was one of the first user modeling systems (seealso Section 2.2). In Grundy, user preferences concerning book contents are modeled.A user model consists of a set of attributes (also called facets) with user-specificvalues. There are two kind of attributes: Attributes of the first kind convey generalinformation about the user (e.g., motivations); attributes of this type can have differ-ent symbolic values. The second kind of attributes correspond to possible proper-ties of book contents (e.g., thrill); they get assigned a numerical value ranging from−5 to 5. For these ‘scalar facets’ this value expresses the preference strength andleads to an SBUPref* graduation. All facets are assigned certainty values on a scalefrom 0 to 1000, representing the strength of the assessment. Altogether, the scalarfacets of a Grundy user model can be represented with atomic propositions fordenoting personal traits; these would be contents of assumption type SB*UPref*.The other attribute-value pairs can be regarded as SB*UProp (meaning: the systembelieves with a certain strength that the user has some property) assumptions. How-ever, for representing the assumption content in logic, propositional calculus is notenough; logical means that could be used to represent non-scalar Grundy facets arediscussed in the next section.

So far, we have only encountered atomic propositions. Complex propositionshave rarely been used in user modeling. One of the few examples is Huang’sSMMS (Student Model Maintenance System; Huang et al., 1991). Like most ofthe systems mentioned above, SMMS models user (more precisely: student) know-ledge of the (teaching) domain. The assumptions are represented by atomic propos-itionsA (representing ‘the student knows the concept/fact/etc.A’) and by negatedatoms¬A (representing ‘the student does not knowA’); they are contained in thedefault packages. Additionally, SMMS employs rules for inferring new assump-tions from assumptions that were previously acquired. These rules are implicationsthat follow the patternA1∧ . . .∧An→ [¬]B. So, the rule antecedent is a conjunc-tion of atoms, while the conclusion is an atom that may be negated or not. In termsof our approach of separating assumption type from assumption content, SMMSassumptions belong to types SBUB and SB∼UB. For the representation of as-sumption contents, non-negated atomic propositions are sufficient, since negationis expressed by using the SB∼UB assumption type. Consequently, SMMS infer-ence rules permit one to infer SBUB or SB∼UB assumptions from a set of SBUBassumptions (given in the antecedent conjunction). In the following, inference rulesthat relate different assumption types will be encountered quite frequently.


3.1.2. Predicate Calculus

Within formulas of first-order predicate calculus, it is possible to distinguish betweenobjects of the domain under consideration and relationships that may or may notexist between objects. Furthermore, objects can be denoted by both simple constantsymbols and complex functional terms that ‘compute’ objects from other objects.But all this does not make FOPC a theoretically more powerful formalism thanpropositional calculus. The crucial gain of FOPC is that objects can be referred toby quantified variables, which makes it possible to state that something holds forall objects of a given domain (universal quantification) and that something holdsfor at least one object (existential quantification).

Nevertheless, even without variables and quantification, it can be useful to em-ploy FOPC formulas in order to have domain objects and relationships stand outsyntactically. Several user modeling systems have taken advantage of this by usingso-called “ground formulas” of FOPC instead of simple propositions. A typicalexample is the formalization used by Wu (1991) for representing user plans andgoals as well as domain information. E.g., from the user question

How do I get to the center of the bay?

plan information like the following is extracted (Wu, 1991, p. 167):

user-has-plan(plan1)plan-has-goal(plan1,goal1)user-knows-route-goal(goal1,location1,location2)center-of(location2,bay1)

This is a set of ground atoms. Constants denote objects of the domain (likebay1and location2) but also plan representation elements (likegoal1 and plan1).Correspondingly, predicates are used to make statements about domain objects(center-of) or about plan elements (plan-has-goal). The atoms that are builtwith these predicates express domain knowledge of the system. Therefore, theyare SB-type assumptions. Other expressions represent assumptions about the user.The predicateuser-has-plan concerns user plans (and, indirectly, goals), whileuser-knows-route-goal specifies that the goal is to know the route between twolocations. The former predicate is used to express SBUW assumptions, and thelatter predicate can be characterized as expressing SBUWUB assumptions (wantsto believe/know), respectively. In contrast to domain predicates, these “user modelpredicates” convey assumption type information. In Section 3.2.1, several examplesof user modeling work will be presented, where first-order predicates are moreexplicitly used to express assumption type information.

Other examples of using simple FOPC formulas are (Retz-Schmidt, 1991) and(Carberry, 1989). In the latter work, variables appear in the FOPC atoms thatrepresent goals within plan descriptions. However, since these variables can only

230 WOLFGANG POHL

have a finite number of values, Carberry’s goal representation does not exceedpropositional calculus.

Only a few systems have used more complex FOPC mechanisms for user mod-eling. ANATOM-TUTOR (Beaumont, 1994), a tutoring system in the domain ofanatomy, is one example. It employs the rule-based programming language Ops5to express laws of anatomy that students may be assumed to know. In (Beaumont,1994), only an informal example of such a law is presented, namely

“any ganglion which receives nerve-impulses from a parasympathic object isitself parasympathic” (p.33)

Beaumont states that the relations ‘belongs-to-class’ and ‘sends-nerve-impulses-to’are used. Thus, the above law could be represented in FOPC as follows:

∀x, y belongs-to-class(x,ganglion)

∧ belongs-to-class(y,parasympathic-object)

∧ sends-nerve-impulses-to(y, x)

→ belongs-to-class(x,parasympathic-object)

This FOPC rule is an implication with a conjunction of atoms as its antecedentand a single atom as its conclusion. Such implications are Horn rules (the basis ofProlog), which are sufficient for many representational purposes.

An interesting aspect of ANATOM-TUTOR is that domain rules are part of theuser model (assumption type: SBUB) and not of the domain model of the system.They can be used to infer additional assumptions about the user by simulating thederivations the user can perform according to the rules that she is assumed to know.Such simulative inferences based on FOPC rules are also described by Quilici(1989; 1994). Quilici introduces ‘IF. . . THEN. . . ’ rules for deducing beliefs aboutthe desirability of plans or actions. These “explanation rules” correspond to FOPCimplications that are more expressive than Horn rules.

3.1.3. Specialized Formalisms

In the previous sections, example applications of propositional and predicate cal-culus for user modeling were presented. Because of their generality, such logicalformalisms can be employed for very different purposes, but are inherently com-plex. For specific representation and reasoning tasks, specialized formalisms willprobably be more appropriate. In the area of logic-based knowledge representation,one of the most important goals has been the development of formalisms that pro-duce better structuring of knowledge. Beginning with semantic networks (Quillian,1968) and frames (Minsky, 1975), many methods were developed to permit thedescription of prototypical objects or classes of objects (or also situations, in thecase of frames) as concepts of a domain. In most of these formalisms, it is possible


to describe properties of concepts or objects and inheritance or hierarchy relations(often called ISA links) between concepts or between concepts and objects. Inmost cases, the semantics of those formalisms were not clearly described, but itoften turned out that there were only syntactical differences to FOPC.

An important move towards formalisms with well-defined formal semantics forrepresenting concepts, objects, and their relationships was made by introducing thestructured inheritance networks of the KL-ONE system (Brachman & Schmolze,1985). The research efforts following this work have lead to the formal languagesof description logics. An important property of a description logic (and also ofthe core KL-ONE) is that its representational elements have FOPC equivalents.For example, a KL-ONE concept corresponds to a one-place predicate. That is,the standard languages for representing terminological or conceptual knowledgeform subsets of FOPC. However, the special constructs of these languages can beprocessed using specialized methods and therefore much more efficiently than theirFOPC equivalents.

Many user-adaptive systems individualize their behavior according to the user’sknowledge about the concepts of a domain. For instance, explanation generatingsystems will cater to the user’s knowledge about the concepts that are used foran explanation. In information systems like adaptive hypertexts the amount anddetail of information provided may be tailored to the conceptual knowledge of thecurrent user. Consequently, formalisms that are specialized in the representationof concepts, concept hierarchies, or more complex terminologies have quite fre-quently been employed in user modeling systems. Concept hierarchies are oftenpredefined as system domain knowledge (assumption type SB), and user modelcontents (mostly of type SBUB) are relative to this knowledge4.

A typical example of the employment of concept-based representation is thesystem of Moore and Paris (1992), who use expressions like

(CONCEPT C)(ISA C1 C2)

(with C, C1, andC2 standing for arbitrary concepts) as terms of a formalism,which is used to represent SBUB assumption contents. With these terms, concepthierarchies can be described. Similarly, in the formal description of the user modelacquisition rules of the GUMAC system, Kass (1991) uses the primitives

concept(C) C is a conceptproperty(C, P ) conceptC has a propertyPisa(C1, C2) conceptC1 is a subclass ofC2

that denote concepts, their properties, and their relations. These primitives are notonly related to standard KL-ONE mechanisms; Kass realized them in GUMACusing a KL-ONE implementation.

4 This strategy is often referred to as overlay modeling (Carr & Goldstein, 1977).

232 WOLFGANG POHL

There are many more examples of the use of concept-based formalisms in usermodeling (Sleeman, 1985; Kobsa, 1985; Sarner & Carberry, 1992, Kobsa et al.,1994). But other kinds of specialized logic-based formalisms have also been util-ized. Particularly in plan recognition systems, several formalisms have been em-ployed for representing plan knowledge of the application domain as well as forrepresenting the user’s assumed knowledge about plans and the user’s goals thatindicate a current plan. In work of Carberry (1989; Sarner & Carberry, 1992),STRIPS-like definitions of planning operators with preconditions, applicabilityconditions, effects, and suboperators are employed in the domain knowledge base.Conditions and effects are represented in a FOPC-like formalism. User plans andgoals, however, are represented in a tree-like “context model”, which is a structureof possible goal/subgoal sequences the user may pursue.

In the GUMAC system, Kass employs a representation formalism for problem-solving knowledge that is utilized to model the current activities of the user, and tomodel goal/subgoal relationships. Although in (Kass, 1991), an FOPC notationis employed to refer to actions and goals within the description of GUMAC’sacquisition rules, Kass actually implements problem-solving knowledge using thespecialized formalism EES (the “Explainable Expert System”).

A different approach to plan representation is to use graph-based formalisms forabstraction and decomposition hierarchies of plans and actions, as Goodman andLitman (1992) have done. Abstraction and decomposition hierarchies can be logic-ally formalized, as Kautz (1991) has shown. Weida and Litman (1992) attempt toimplement such a plan representation with a KL-ONE-like formalism that includesmeans for representing temporal relationships.

In several intelligent tutoring systems, so-called “genetic graphs” (Goldstein,1982) are utilized for representing both static and dynamic aspects of the user’sconceptual knowledge. Niem et al. (1993) present extended genetic graphs withnodes representing learner knowledge about facts, concepts, rules, and proceduresof the tutoring domain and with links implicitly representing the student’s learningprocess. The semantics of the nodes and their possible meanings is characterizedin a logic-based formalism, namely conceptual graphs, while the semantics of thelinks is described with predicate transition networks.

All of the above examples show that the use of specialized formalisms forspecial purposes is wide-spread in user modeling. For user modeling shell sys-tems, we conclude that representation and reasoning facilities should not be builtupon a single, all-purpose formalism (like modal logic), but should rather offer arange of mechanisms for the developer to choose from. Ideally, a shell would dy-namically integrate special representation mechanisms into its general user modelrepresentation and reasoning framework.


3.2. REPRESENTINGASSUMPTIONTYPE AND CONTENT

In the previous section, we described examples of the use of logic-based form-alisms for representing assumption content. In most of the systems discussed,only content information is represented. However, the developers of some of themsought to represent both type and content information. This was done in many othersystems, too. As will become clear in this section, in most cases a single powerfulformalism is used, namely either FOPC with special predicates or modal logic withits operators for representing type information.

3.2.1. Using FOPC with Special Predicates

First, we will take a closer look at a simple but typical example, the assump-tion content representation of which was already discussed in Section 3.1.3. Thepossible user model contents that are described by Moore and Paris (1992) areinstances of one of the following patterns:

– (GOAL USER goal)The user is assumed to have a certaingoal.

– (BEL USER p)The user is assumed to believe in a propositionp. Propositions may refer todomain concepts, like(CONCEPT C) or (ISA C1 C2), or to possible actions andgoals of the user, like(STEP action goal).

– (COMPETENT USER comp)The user is assumed to have the competencecomp. Competence expressionsmay be either(DO USER action) or (ACHIEVE USER goal).

All these expressions can be regarded as FOPC formulas. More precisely, they areground atoms, with predicates ‘goal’, ‘bel’, and ‘competent’ for assumption typeinformation, and with functions like ‘concept’, ‘isa’, ‘step’, ‘do’, and ‘achieve’ forthe construction of terms that denote assumption contents. Assumption type andcontent information is clearly separated, so that user model contents can easilybe rewritten using our notation for assumption type expressions. Let the types ofthe above assumptions be denoted with SBUW for goals, SBUB for believes, andSBUC for competences. Then, the assumptions can be expressed (using FOPC ascontent formalism) as

SBUW:goalSBUB:concept(C), SBUB:isa(C1, C2), SBUB:step(action, goal)SBUC:do(action), SBUC:achieve(goal)

The content terms from above have become content formulas, the functions havebecome predicates. Note that the ‘user’ parameter of ‘do’ and ‘achieve’ could beomitted because of its redundancy.

A closer look at the content formulas shows that specialized formalisms mightbe used to represent assumption contents more appropriately. ‘Concept’ and ‘isa’

234 WOLFGANG POHL

expressions could be handled by a semantic network formalism, a KL-ONE-likesystem or a more modern description logic. Actions and goals could be representedin a graph-based formalism for actions and plans as in (Cohen et al., 1991; Good-man & Litman, 1992). See Section 3.1.3 for a discussion of specialized representa-tion formalisms. However, this example indicates that such specialized formalismswill often belogic-basedin the sense that their structures correspond to expressionsof classical logic.

Another example of using special FOPC predicates for assumption type rep-resentation is the work of Quilici (1989; 1994). Besides complex FOPC rules (seeSection 3.1.2), Quilici’s central representation facility is a predicate

belief(B,R),

whereB is either the ‘user’ or the ‘advisor’, andR may be a piece of planningknowledge. As Quilici (1989) explains: a ‘belief(B,R)’ expression ‘represents anadvisor’s belief that an actor maintains that a particular plan applicability condition,precondition, or effect holds. The actor is either the user or the advisor’ (p. 112).Hence, ‘belief(B,R)’ expressions correspond to either SBUB or SBSB assump-tions. However, the reflexivity in SBSB seems redundant; expressions of the form‘belief(advisor,R)’ can be regarded as SB assumptions.

Appelt and Pollack (1992) use a more complex representation in their weightedabduction approach to plan recognition. They introduce predicates like INT(a, α)

(agenta intendsα), BEL(a, p) (agenta believesp), or ACH(a, p) (agenta be-lievesp will become true as a consequence of the action he performs)5. These pre-dicates are called ‘epistemic operators’; their arguments are agent symbolsa, fac-tual propositionsp, and actionsα. Using these predicates, Appelt and Pollack formspecial rules–which correspond to FOPC implications–that aid in deducing the in-tentions of an agent (e.g., of the user). In the weighted abduction approach, the rulesare applied in a kind of backward reasoning process. Within these rules, differentepistemic operators appear, so that a division into assumption type and content isnot possible. This is not surprising, since the rules are not considered assumptionsabout the user but inference rules of the system that refer to different assumptiontypes. However, it becomes clear thatAT : ac assumption type expressions are notsufficiently expressive for representing such type-external relationship rules.

In all formalisms that use FOPC with special predicates for assumption typerepresentation, there is a severe limitation: Assumption contents are terms of FOPC,which cannot be processed by FOPC reasoning in the same way as real formulas.For example, deductions based on assumption contents are not possible. In thenext section, uses of modal logic for user modeling are presented. In modal logics,special language elements (modal operators) are added to classical logics and canbe used to represent assumption type information without restricting assumptioncontent representation.

5 ACH is an abbreviation of ‘achieves’.


3.2.2. Using Modal Logic Operators

In a user model, assumptions or beliefs about the user are represented. These sys-tem beliefs will often be concerned with the knowledge or beliefs of the user, butalso about user goals, interests or preferences. All of these notions can be regardedas modalities which can be represented using modal logics with their operators.

3.2.2.1.Hustadt’sF ALCM. In Section 2.3, we introduced a notation for modalformulas using a generic operator2(m,a). This notation is also used by Hustadt(1994; 1995) who adds the generic modal operators2(m,a) and3(m,a) to the de-scription logicALC. Thus, he has a multi-modal, multi-agent description logic,which can make concepts and roles as well as terminological and assertional sen-tences of the logic relative to agents’ attitudes (‘subjective’ in Hustadt’s terms).Because it introduces a powerful approach to representing and reasoning withstereotypical assumptions, Hustadt’s formalismF ALCM is well suited to usermodeling, with system and user as agents. Imagine a system that models the user’sassessment of cars6. An example of a subjective concept is

2(B,U) nice-car,

which denotes the class of all objects that are believed by the user to be nice cars.An interesting property of Hustadt’s formalism is that agent symbols are object

symbols of the terminological language, and that concepts therefore can describeclasses of agents. Such agent conceptsA are used in combination with the specialmodal operators2c(m,A) and3c(m,A) for common (i.e., mutually shared) attitudes ofan agent class, and2g(m,A) and3g(m,A) for group attitudes of an agent class. Theseoperators can be employed to formulate stereotypical assumptions, which can beheld by any agent. For example,

2(B,S)2g(B,porsche-owner)(bmwv slow-car)

means that the system believes all Porsche owners classify BMWs as slow cars.The above example expressions can still be split into assumption type and con-

tent7. F ALCM, however, allows for formulas that go beyond assumption typeexpressions, which is illustrated by the following slight modification of an examplegiven in (Hustadt, 1995):

2(B,a)(nice-carv 2g(B,porsche-owner)slow-car).

This expression means that agenta believes that nice cars are among the objectsthat are believed by Porsche owners to be slow cars.

6 The examples in (Hustadt, 1995) are from the car domain, too.7 The stereotypical assumption can be regarded as SBUB assumption (cf. Section 5.1.2).

236 WOLFGANG POHL

3.2.2.2.Combining modal logic and plan recognition. A second application ofmodal logic in user modeling is presented by Ardissono and Sestro (1996), whodescribe a method for combining plan recognition with a model of user beliefs,knowledge, and interests. They use a rich language with operators for expressingknowledge, belief, and intentions. Its syntax is similar to FOPC, with agents andformulas as operator arguments, e.g., Bel(agt, p) for beliefs, K(agt, p) for know-ledge (defined as Bel(agt, p) ∧ p), Goal(agt, p) for goals, and Intend1(agt, a),which expresses the intention to perform an action. Thep anda arguments may befull first-order expressions, as in

Bel(U,∀x Professor(x)→ Department-employee(x)). (1)

This formula represents the assumption that the user believes that a ‘Professor’ isa ‘Department-employee’. A more complex example is

Bel(agt,post(act, c)) ∧Goal(agt,¬c)→ ¬Intend1(agt, act).

This rule says that an agent does not want to perform an action if she believes thatthe action will have an undesired effect. Since different modal operators appear inthis rule, it represents a type-external relationship (cf. Section 2.3.2).

Several remarks can be made concerning this work:

– All examples of user model contents are “modal literals”, i.e., simple for-mulas of the form[¬]Op(agt, p) whereOp is a modal operator,agt is anagent symbol, andp is a first-order formula. Such a basic modal expression isvery similar to theAT : ac notation of assumption type expressions. Together,Op andagt determine the type of an assumption, andp can be regarded asassumption content. For instance, the above formula (1) could be rewrittenas assumption contentisa(Prof,Dep-emp) of type SBUB. The correspondencebetween simple modal formulas and assumption type expressions will be ex-ploited in Section 5 to build a bridge between assumption types and modallogic.

– Possible content expressions concern either conceptual knowledge, as in theexample above, or planning knowledge. Both kinds of contents can be for-mulated only in FOPC. However, for planning knowledge, a distinct set ofpredicates is introduced. This indicates that the use of specialized formalismsfor conceptual knowledge on the one hand and planning knowledge on theother hand might be helpful.

– As was observed for Appelt and Pollack (1992), complex formulas of themodal language are mainly used to express acquisition rules, i.e., rules thatthe system can apply to infer additional assumptions from existing user modelcontents. Since different operators can appear in acquisition rules, the rulesestablish type-external relationships.


Table Ia. Representation in user modeling: assumption content only.

formalism remark system/literature assumption types

propos. atoms (Paris, 1989) SBUB

calculus (Nwana, 1991), (Tattersall, 1992), SBUB*

Techdoc-I (Peter & Rösner, 1994)

UMFE (Sleeman, 1985) SB*UB

Grundy (Rich, 1983) SB*UPref*

rules SMMS (Huang et al., 1991) SBUB, SB∼UB

FOPC atoms (Wu, 1991) SBUW, SBUWUB

variables TRACK (Carberry, 1989) SBUW

rules ANATOM-TUTOR (Beaumont, 1994) SBUB

special concepts (Moore & Paris, 1992), SB, SBUB

GUMAC (Kass, 1991)

others (Goodman & Litman, 1992), div.

(Niem et al., 1993)

Table Ib. Representation in user modeling: assumption type and content.

formalism system/literature assumption types

FOPC (Moore & Paris, 1992) SBUB, SBUW, SBUC

(Quilici, 1989; Quilici, 1994) SBUB, SB

(Appelt & Pollack, 1992) SBUB, SBUInt, . . .

modal logic (Hustadt, 1994; Hustadt, 1995) SBUB, . . .

(Ardissono & Sestero, 1996) SBUB, SBUK, SBUW, SBUInt

3.3. SUMMARY

In this section, we have given an overview of logic-based representation methodsemployed in user modeling systems. This overview is summarized in Table Ia,covering pure assumption content representation, and Table Ib, listing work onrepresenting assumption type and content. Both tables list representation formal-isms, systems that use these formalisms8, and the assumption types involved. In theassumption type labels, C stands for ‘has competence’, K for ‘knows’, and Int for‘intends’. The contents of the remark column in Table Ia indicate which features ofthe corresponding formalism were used.

From our presentation of a wide range of different representation facilities foruser modeling in this section the following observations can be made:

8 The table does not exhaustively list all systems mentioned in this section.

238 WOLFGANG POHL

– Assumption type expressions are sufficient to express the user model contentsof many systems. However, there is also a significant number of systems whichmake use of type-external expressions beyond theAT : ac format.

– A wide variety of formalisms has been used for representing assumption con-tents, especially in systems without representation of assumption type inform-ation. In addition to standard logical formalisms like propositional and predic-ate calculus, various specialized formalisms have been used in systems withspecialized representation needs.

– Even in systems using modal logic or a similar FOPC representation, the di-chotomy of assumption type and content can be observed. The use of modallogic prohibits the use of specialized formalisms for content representation.However, we have seen an example expression which corresponded to anAT : ac expression where the content part could have been represented using aspecialized concept-based representation.

– Type-external representation facilities can be employed to express system-levelinference rules.

These observations suggest that modal logic should be offered in any user mod-eling shell that attempts to be widely applicable. However, also less complex mech-anisms for dealing with assumption type expressions are sufficient for many sys-tems and should therefore also be available. These mechanisms should also permitthe use of specialized formalisms for representing assumption contents. That is, be-sides providing powerful facilities a shell needs to offer flexible access to mechan-isms of lower complexity and perhaps specialized abilities, which can neverthelessbe integrated into the machinery of the more powerful tools.

4. Reasoning

One of the most important properties of a knowledge representation formalism(whether logic-based or not) is that it allows conclusions to be made from explicitlyrepresented knowledge, thus permitting access to knowledge that is only implicitlycontained in a knowledge base. In case of logic-based knowledge representation,this is usually formalized as follows: A knowledge baseKB is a model of anexpressionφ (short:KB |= φ) if φ is semantically entailed by the set of expres-sions inKB. This semantic relationship is implemented by a calculus that derivesexpressionsφ syntactically from a knowledge baseKB (short:KB ` φ). Ideally,the derivation relation equivalently implements the semantic relation|=. In thiscase, the calculus is called sound and complete.

The derivation capabilities of logic-based formalisms are also useful for usermodeling. In most user modeling applications, it is difficult to directly acquireassumptions about the user that are sufficient to support the desired individual-izations. Users will not often tell the system voluntarily and explicitly about theirindividual properties and attitudes. Furthermore, in order to avoid intrusiveness, itis generally best not to ask the user too many questions. For this reason, it is often


necessary for a user modeling system to infer the required assumptions about theuser.

With regard to user modeling and, in particular, user model acquisition two maintypes of inferences can be distinguished:

– Assumptions about the user can be inferred from data outside the user model,e.g., observations of user behavior like logs of command sequences. Such as-sumptions will be calledprimary assumptions; we will refer to the inferenceprocesses that lead to primary assumptions asprimary inferences.

– Assumptions about the user can also be derived from user model contents.For instance, it can be plausible to assume that a user knows a fact if she isalready assumed to know many related items. Such assumptions are depend-ent on other user model contents and will be calledsecondary assumptions.Correspondingly, we will also speak aboutsecondary inferences.

Inference mechanisms of knowledge representation formalisms are more appro-priate for secondary inferences than for primary inferences, since they draw con-clusions from explicitly formulated knowledge items and therefore are designed tooperate ‘within’ a knowledge base. However, such a mechanism could conceivablyalso serve as an engine for primary inferences. As a prerequisite, ‘data outside theuser model’ would have to be coded in the respective representation formalism.

In this section, we will present several examples of inference methods that havebeen employed in user modeling systems. We will focus on logic-based reasoningand inferences, but will also describe other methods. Based on this description,we will attempt to classify user modeling inferences and to identify some standardreasoning tasks of user modeling systems for which user modeling shells shouldprovide implementations.

4.1. FORWARD REASONING FORUSER MODEL ACQUISITION

The classical way of doing logic-based, deductive reasoning is to derive a conclu-sion from given premises. Formal deductive systems, from Aristotelian inferencepatterns to Hilbert calculi, consist largely of inference rules that enable us to formstatements that semantically follow from previous statements. Therefore, it seemsnatural to apply logic-based reasoning mechanisms in knowledge-based systemsin a forward-chaining manner, i.e., to start with a given knowledge base and/ora given expression and determine the logical consequences. In user modeling,forward-directed reasoninghas been used to acquire both primary and secondaryassumptions. Typically, forward inferences will be invoked when a new observa-tion about the user is made or when a new assumption about the user is acquired,respectively. The new observation or assumption then constitutes the starting pointfor the forward-directed reasoning process.

Our first example is KNOME, the user modeling component of the “Unix Con-sultant” UC (Chin, 1986; Chin, 1989). For user model acquisition, KNOME relies

240 WOLFGANG POHL

on its double-stereotype approach (see Section 4.3) and on a set of rules for primaryinferences. An example rule is

user usesX→ user knowsX

This rule refers to a user action. If the user is observed to use an interaction entity(e.g., a system command), the user is assumed to know this entity. This rule, likeother KNOME rules, is domain-independent.

A second example is the system of Ardissono and Sestero (1996) which em-ploys a modal logic for representing user model contents as well as user modelacquisition rules. The following acquisition rule was presented in Section 3.2.2:

Bel(agt,post(act, c)) ∧Goal(agt,¬c)→ ¬Intend1(agt, act).

Since the premises of this rule refer to assumed beliefs and goals of an agent, whichare already part of the agent model, it supports secondary inferences. Together withthree more rules, it is applied in a forward manner to ‘expand’ the user model, as theauthors put it. Note that, like the acquisition rules of KNOME, the rules themselvesare not part of the user model. They can be regarded as system knowledge that isused formeta-level reasoningabout the user model.

In inferences for user model acquisition, domain knowledge can play an import-ant role. An early example is the UMFE system (Sleeman, 1985), the ‘User Mod-eling Front-End’ of the expert system NEOMYCIN. UMFE employs the domainknowledge of NEOMYCIN to extend its user model through secondary inferences.In the domain knowledge base, a taxonomy of bacterial infections is representedas conceptual hierarchy. Every concept is labeled with two values that character-ize difficulty and importance of the concept with respect to second-year medicalstudents. This information is employed by inference rules like

If a concept is known/not known, then its parent concept in the hierarchy andall of its siblings which have comparable or higher importance values will alsobe known/not known.

Note that UMFE inferences are secondary, since they rely on prior assumptionsabout the user.

Similar to UMFE, the adaptive hypertext system KN-AHS (Kobsa et al., 1994)bases its secondary inferences (regarding the user’s knowledge of domain con-cepts) on terminological domain knowledge which is available in the user modelingknowledge base of KN-AHS.

There are many other systems that use forward-directed inferences for usermodel acquisition, among them GUMAC (Kass, 1991), the system developed byZukerman and McConachy (1993), and SMMS (Huang et al., 1991). Forward de-rivation is the logical way of inferring primary assumptions: In order to achieve anup-to-date image of the user, new information about the user should immediatelylead to new assumptions about the user.


4.2. BACKWARD REASONING FORANSWERING USER MODEL QUERIES

Since the main point of exploiting a user model is to access it if information aboutthe user is needed, a user modeling system must provide a mechanism for queryingthe user model. When an application system needs to individualize an aspect ofits behavior, it can use the query mechanism to check whether certain assumptionsabout the user are held or not, or, for graduated assumptions, to which degree theyare held. Due to the reasoning capabilities of logic-based knowledge representa-tion systems, a knowledge base query also has access to implicit knowledge. Forthe purpose of answering queries, a representation system employs an inferenceengine to check whether a queried item can be derived from a knowledge base.Such query-driven reasoning works in a backward-chaining manner, attemptingto find knowledge base contents that entail the query. In logic-based user model-ing systems,backward-directed reasoningcan be used analogously for answeringqueries to the user model. Although this seems to be reasonable for user modelingsystems, it has not been employed very often. Actually, each of the examples de-scribed in the following paragraphs presents a somewhat special use of backwardreasoning.

In the system of Zukerman and McConachy (1993), inference rules are utilizedfor content planning in a tutoring environment. The rules describe the effects ofsystem utterances on the beliefs of students. So, if the system intends to make theuser believe a certain proposition about the learning domain, it applies the rules ina backward-chaining manner to determine the utterances from which the intendedbelief can be inferred by the student. This process can be regarded as a “look-aheadquery” to the user model.

In several papers, Quilici (1989; 1994) has developed methods for natural-language advisory systems. For handling plan-oriented user misconceptions, heuses backward-directed deductive reasoning to verify advisor beliefs about rela-tionships between possible user actions and their effects. Deductive inferencescan be drawn based on ‘IF . . . THEN. . . ’ explanation rules. These rules canbe used for inferences concerning both system (“advisor” in Quilici’s terms) anduser. However, in the main algorithm of the advisory system (Quilici, 1989), onlysystem beliefs are verified: The system processes user beliefs that result from atransformation of the user’s natural-language problem description. For a user be-lief, the system determines whether the advisor also holds this belief. If this is notthe case, the system secondly attempts to verify advisor beliefs that contradict thisuser belief according to the advisor’s own planning knowledge. For both steps,backward reasoning based on explanation rules can be applied. Note that explana-tion rules are ascribed to the agent (the advisor or the user) whose beliefs are to beverified. That is, the inference process simulates the inferences of advisor or user.Suchsimulative reasoningis in contrast to meta-level reasoning, which is based onsystem knowledge and is often employed in forward-directed user model acquisi-tion (see previous subsection). Simulative inferences can be particularly interestingin student modeling, where the inference rules or reasoning strategies of students

242 WOLFGANG POHL

may be considered by student model reasoning processes, as in the TAGUS system(Paiva & Self, 1995) (cf. Section 7.1).

Although, backward reasoning is actually only rarely used for answering quer-ies to the user model (one further example is the work of Appelt & Pollack, 1992), itcan be helpful. We agree with Kass (1991), whose system (GUMAC) uses forwardreasoning for both simulative and meta-level inferences. Kass argues, however,that it would probably be better to draw only a limited number of inferences byforward reasoning and to extend the user model by backward reasoning wheninformation is requested from the user model. The reason behind this argumentis that backward reasoning is more goal-directed and therefore more efficient thanforward reasoning. It must be noted, however, that this assessment may depend onthe structure of the inference space that is induced by a set of rules.

Since the main feature of a logic-based representation formalism is that it providesbackward deductive reasoning procedures, a logic-based user modeling system willnaturally offer the option of employing backward inferences for query answer-ing. But on the whole a combination of backward and forward inferences seemsappropriate, since forward reasoning has one important advantage: Typically, ap-plications do not wait for results when a new observation about the user or existinguser model contents are processed by forward-directed user model acquisition.Therefore, forward reasoning can be regarded as anoff-line acquisition method (s.Chin, 1993), while backward-directed query answering is a typicalon-linemethodforcing applications to wait for answers.

4.3. INFERRING STEREOTYPICAL ASSUMPTIONS

For human beings, a simple method of making initial assessments of others isto classify them and then make predictions about them according to a corres-ponding stereotype, i.e. the standard assumptions about members of that class(McCauley et al., 1980). The use of stereotypes in computer systems that maintainmodels of their users was introduced by Rich (1979; 1983) with the Grundy system.According to Rich (1989), the main components of a stereotype are

– a body which contains information that is typically true of users to whom thestereotype applies, and

– a set of triggers, which decides whether the stereotype applies to a user. Hence,the triggers typically refer to assumptions about the user. Often, triggers are asubset of the stereotype contents.

In the following, stereotypes that adhere to this definition will be calledcontainerstereotypes, since they can be regarded as containers of assumptions about usersthat belong to a specific group.

The act of applying a stereotype to an individual user, which Kobsa (1990) callsstereotypeactivation, is the result of a forward-directed, meta-level (stereotypes


are system knowledge) inference process. Whether the inference is secondary orprimary depends on whether the triggers refer to user model contents or not.

Chin (1993) characterizes stereotypes as a grouping of inference rules into tworules of the form

triggers→ stereotype applies

stereotype applies→ body

However, there are only few user modeling systems that actually use rules or otherexpressions of their standard formalism to represent stereotypical assumptions.In this case, the reasoning capabilities of the formalism are used for stereotypeinferences. Examples are ANATOM-TUTOR (Beaumont, 1994), which makes useof production rules (cf. Section 3.1.2), and the modal description logicF ALCM(Hustadt, 1995), which allows for the representation of personalized stereotypes ofseveral agents (cf. Section 3.2.2). More often, container stereotypes are employed,e.g. by the HAM-ANS system that constructs a user profile on the basis of severalstereotypes (Morik, 1989) and by Moore and Paris (1992).

The container approach described above can be extended to represent not onlysufficient conditions for the application of a stereotype in form of triggers, butalso necessary conditions, as in (Kobsa, 1990) and (Shifroni & Shanon, 1992).The evaluation of necessary conditions may lead to thedeactivationor retractionof stereotypes. This means that stereotype contents are no longer inherited by theuser model. Note that stereotype retraction is a nonmonotonic inference. A furtherextension to basic container stereotypes is the use of inheritance hierarchies forstereotypes, which permits the introduction of subsumption relationships betweenuser groups (see Grundy or Ardissono & Sestero, 1996, for examples).

In many user modeling systems, assumptions about the user are relative tosystem domain knowledge. Therefore, a further development of stereotype reas-oning grew from the idea that just as possible assumptions about the user can begrouped according to a classification of potential users, system knowledge can begrouped according to certain criteria. Thisdouble-stereotypeapproach was intro-duced in KNOME (Chin, 1986; Chin, 1989). In KNOME, users are categorized atdifferent levels of expertise: novice, beginner, intermediate, and expert; and systemknowledge (i.e., UNIX commands) is grouped into four levels of difficulty: simple,mundane, complex, and esoteric. Then, the basis for stereotype inferences is a rela-tion between user stereotypes and difficulty levels. The general idea is to say that ata specific level of expertise, concepts (UNIX commands in the case of KNOME) ofa specific set of difficulty levels are known. Jameson (1992) further worked out thedouble-stereotype approach based on insights from psychology. A related approachwas taken in the generic tutoring system SMMS (Huang et al., 1991), where theconcepts of the teaching domain are thematically grouped intodefault packages.For each such package, the user is classified separately, but classifications in relatedpackages can influence each other.

244 WOLFGANG POHL

Table IIa. Meta-level inferences in user modeling systems

primary forward: KNOME (Chin, 1989),

GUMAC (Kass, 1991)

backward: –

mixed forward: (Zukerman & McConachy, 1993)

backward: (Zukerman & McConachy, 1993)

secondary forward: SMMS (Huang et al., 1991)

GUMAC (Kass, 1991),

UMFE (Sleeman, 1985),

(Ardissono & Sestero, 1996,

backward: (Appelt & Pollack, 1992)

Table IIb. Simulative inferences in user modeling systems.

secondary forward: GUMAC (Kass, 1991)

backward: (Quilici, 1989; Quilici, 1994)

In sum, for stereotype inferences special mechanisms are needed which gobeyond the inference capabilities of representation formalisms. Nevertheless, ste-reotypes are a popular means of user model acquisition, so a user modeling shellsystem should offer stereotype facilities.

4.4. LOGIC-BASED REASONING SERVICES FORUSER MODELING

So far, we have identified three dimensions for characterizing reasoning tasks inuser modeling systems. First, the general distinction between forward-directed andbackward-directed inferences is also relevant to user modeling. More specific touser modeling is the distinction between simulative reasoning (i.e., reasoning basedon knowledge ascribed to the user) and meta-level reasoning (based on know-ledge of the user modeling system). Most specific to user modeling systems isthe distinction between primary and secondary inferences.

Tables IIa and IIb classify the systems that have been mentioned in this sectionaccording to the kind of inferences they employ. While Table IIa lists systems withmeta-level inferences, Table IIb mentions systems with simulative inferences. Inboth tables, further classification dimensions are primary vs secondary (vs mixedprimary and secondary) inferences, and backward vs forward inferences. Table IIbis very short; none of the mentioned systems does simulative primary inferences.This is not surprising: It seems unintuitive to ascribe to the user rules which shewould herself use to infer assumptions about her based on her activities.


We will now try to identify how logic-based methods can be used for all thedifferent kinds of user modeling inferences. First, the inference mechanisms offormalisms which are employed for the representation of UMKB contents will dealwith secondary inferences by definition. Primary inferences can be supported onlyif primary acquisition knowledge is coded in the same formalisms as user modelcontents are. Second, the distinction between simulative inferences and meta-levelinferences is typically not reflected by different inference mechanisms, but by thedifferent kinds of knowledge upon which inferences are based. Simulative infer-ences process knowledge ascribed to the user, while meta-level inferences processsystem knowledge. Hence, the main requirement for inference mechanisms in usermodeling is that they should provide access to implicit user model contents byeither forward or backward reasoning.

For logical reasoning systems, Russell and Norvig (1995) minimally requiretell andask functions that can be used to add an expression to a knowledge baseand to issue a knowledge base query. These functions can involve the followingsub-functions:

store adds a new fact to the knowledge base.forward derives some of the facts implied by the conjunction of the knowledge

base and an additional (perhaps new) fact.fetch decides if a query is explicitly stored in the knowledge base9.derivable decides whether a queried expression can be derived from the know-

ledge base.

In addition, aconsistentfunction, which checks whether a new fact is consistentwith the knowledge base, may constitute another sub-function oftell.

The abovetell andask sub-functions match the requirements of user modelingsystems: they allow for forward and backward inferences and additionally offer thepossibility of data-base-like access to user models. Even stereotype inferences maybe supported by these functions, if stereotypes and stereotype triggers are integ-rated into the user model representation formalism, as in Hustadt’sF ALCM. Forcontainer stereotypes, special mechanisms are needed, which must be integratedinto the overall representation and reasoning system.

In a user modeling system, it should be clear whether or nottell andask involveforward and backward reasoning, respectively. A user modeling shell that providespowerful representation and full access to reasoning mechanisms would implementtell as ‘store and forward ’ and ask as ‘if not fetch then derivable’. However,a shell that offers flexibility to the developer of an application system would letthe developer decide when to use reasoning mechanisms. In the next section, wewill describe our framework for powerful and flexible logic-based user model rep-resentation and reasoning and show howtell, ask and the other functions can be

9 In the naming ofstore andfetch, we follow Russell and Norvig (1995).

246 WOLFGANG POHL

flexibly implemented in a system that is based on the dichotomy of assumptiontypes and assumption contents. We will also show how container stereotypes canbe integrated into such a system.

5. Assumption-Type Representation Framework

In Sections 3 and 4, we discussed the use of logic-based representation and reas-oning in user modeling systems and corresponding requirements for user modelingshells. With regard to user model representation, two main tendencies were ob-served. On the one hand, many systems use representation formalisms only forassumption contents, while type information is expressed by storing assumptioncontents in (type-specific) knowledge bases. Frequently, when there is only onetype of assumption, this knowledge base is identical to the user model. On theother hand, logical formalisms can be used to express both assumption type andcontent information of a user model entry in an integrated way.

Section 2 dealt the main approaches to representing assumption type inform-ation that can be found in the literature on user modeling and, more generally,on belief modeling. These approaches parallel the above-mentioned tendencies.First, there is the partition approach, which distinguishes assumptions of differenttypes by storing them in separate knowledge bases; second, there is the modal logicapproach, which uses the operators of modal logic to deal with assumption type in-formation. Both approaches were discussed as candidate knowledge representationparadigms for user modeling shell systems. The partition approach was found tohave a greater potential as far as flexibility is concerned, while modal logics offermore reasoning power and are based on clear semantics.

In this section, a framework for logic-based user model representation and reas-oning is presented that mainly follows the partition approach but integrates modallogic representation and reasoning. Its central notion is theassumption type, henceits name ‘Assumption Type Representation Framework’ (AsTRa). Its main featuresare:

– Assumptions about the user are distinguished according to their type by stor-ing assumption content information in type-specific, partition-like knowledgebases, which we callassumption types.

– Assumption contents can be represented in any logic-based formalism, i.e., ina formalism that both provides standard logical reasoning mechanisms and canbe semantically characterized in terms of (first-order) logic.

– With assumption types and content formalisms,AT : ac expressions can berepresented by storing the assumption contentac in assumption typeAT . Rep-resentation of and reasoning with these basicAsTRa expressions are provablyequivalent to representation and reasoning within a limited modal logic. Hence,the basic mechanisms can be extended with full modal logic representation andreasoning.


– Based on the modal logic semantics ofAsTRa, specialized mechanisms fordealing with negative assumptions (i.e., assumptions about what the user doesnot believe, want, etc.) can be introduced.

Due to these features,AsTRa makes two main contributions to user modelrepresentation and reasoning:

– It combines the partition approach with the modal logic approach to user mod-eling on the basis of a semantics of its basic, partition-like facilities. Thus, itovercomes deficiencies of previous partition-oriented approaches by allowingfor representation and reasoning beyond partitions.

– It offers a high degree of flexibility by allowing for several, possibly special-ized formalisms for assumption contents and by permitting free access to allits mechanisms.

In the rest of this section, we will introduce the basic notions of theAsTRaframework, demonstrate their relationship to modal logic, and introduce modallogic and negative assumption types as extensions to the basic mechanisms.

5.1. ASTRa: BASIC MECHANISMS

5.1.1. Assumption Types

Like a partition, an assumption type is a partial knowledge base. It contains all usermodeling knowledge of one kind, e.g., all assumptions about user preferences, allsystem domain knowledge, or all mutually believed user goals. In the partitionapproach and other work on belief modeling (e.g., Taylor et al., 1996), a standardway of labeling assumption types is used which we will adopt and extend for usermodeling purposes. Thus, an implementation ofAsTRa will be able to represent awide range of assumption types, as is desirable for a user modeling shell.

In AsTRa, an assumption type label is a sequence of agent-modality pairs. Pos-sible agents are S (system) and U (user), and there is at least one modality B (forbelief). Typically, the set of modalities is extended with W (for wants/goals), butother modalities are also possible, for example, I for interests. Modalities can bepaired with both agents, but typically only B will be used with S. Together with B,the special agent M can be used to express mutual belief (cf. Section 2.2). In orderto emphasize that all user model contents are system assumptions which are notclaimed to be objectively true, all assumption type labels begin with the pair SB.

Assumption type labels can be read intuitively, e.g. SBMBUW stands for ‘theSystem Believes that it is Mutually Believed that the User Wants’. Other examplesof possible assumption types are SBUB, SBMBUB, SBUW, etc. (cf. Kobsa & Pohl,1995). The assumption type SB is somewhat special; its purpose is to contain sys-tem knowledge that is needed within a user modeling component. On the one hand,SB may contain information about the user that does not fit into other assumption

248 WOLFGANG POHL

Figure 3. Stereotypes and assumption types.

types. On the other hand, SB offers room for general domain knowledge that isrelevant to the user modeling process.

As before, we use the labelAT to denote an arbitrary assumption type. Whenwe want to explicitly refer to the knowledge base of an assumption type, we willuse the notation KBAT .

5.1.2. Stereotypes

TheAsTRa framework also allows for the representation of stereotypes. However,stereotypes do not constitute distinct assumption types. If a user is identified as amember of a given user group, the stereotypical assumptions about this group be-come part of the system assumptions about the user. So, stereotypical assumptionsbelong to assumption types like SBUB, SBUW, etc., depending on whether theymake a statement about beliefs, goals or other attitudes of group members.

The AsTRa approach to representing stereotypes is in line with the containerapproach to stereotype representation. InAsTRa, however, several containers mayexist for a stereotype, each of which is associated with a different assumptiontype. That is, a stereotype is a set of knowledge bases each of which containsassumptions of one type. A typical naming of these knowledge bases would resultfrom replacing the U agent symbol in the corresponding assumption type by thestereotype name. For instance, the SBUB-related knowledge base of a stereotype‘novice’ could be labeled SBnoviceB. Figure 3 illustrates the relationships betweenstereotypes and assumption types inAsTRa. There are two stereotypes: ‘novice’and ‘expert’. While ‘novice’ consists of two knowledge bases that are associatedwith the assumption types SBUB and SBUI (let I be short for ‘is interested in’),‘expert’ consists of only one knowledge base that contains SBUB assumptions.

An AsTRa implementation (further on also called “AsTRa system”) needs toprovide means for dynamically adding and removing stereotype contents to andfrom assumption type knowledge bases. Such means can be used to implementstereotype activation and retraction.


5.1.3. Logic-Based Assumption Contents

Assumption types are partial knowledge bases in the user modeling knowledgebase of anAsTRa system. Knowledge representation formalisms are needed torepresent assumption contents within the assumption type knowledge bases. Theplural in ‘formalisms’ is used intentionally: AnAsTRa system may provide severalformalisms for representing assumption contents.

An AsTRa content formalism must belogic-based. This means that from a prag-matic point of view, such a formalism must provide the standard knowledge baseaccess functions of logical formalisms which were discussed in Section 4.4. From atheoretical point of view, it is required that syntax and semantics of a formalism canbe related to first-order logic. If all content formalisms meet these requirements, thebasicAsTRa mechanisms can be formally characterized in terms of modal logicand a modal logic extension to these mechanisms can be defined.

Essentially, a formalismF consists of two components: a languageLF , i.e., theset of all well-formedF expressions, and a derivation relation`F that determineswhat can be derived from anF knowledge base. On that basis, we can specify theknowledge base access functions that anAsTRa content formalismF is requiredto offer, namelystoreF , fetchF , forwardF , derivableF , andconsistentF . All thesefunctions are boolean-valued; while the first two allow for data-base like accessto knowledge bases, the other three involve inferences. A formal specification isas follows (letac be an expression ofF , and let KBAT be an assumption typeknowledge base):

storeF (KBAT , ac) addsac to KBAT and returnstrue.

forwardF (KBAT , ac) computes some of the expressionsac′ that can be derivedfrom the conjunction of KBAT andac, (i.e., KBAT ∪ {ac} `F ac′), invokesstoreF (KBAT , ac

′) on them and returnstrue.consistentF (KBAT , ac) returnstrue iff ac is consistent with KBAT (there is a model

for KBAT ∪ {ac}).fetchF (KBAT , ac) returnstrue iff ac is explicitly stored in KBAT .

derivableF (KBAT , ac) returnstrue iff ac is derivable from KBAT (KBAT `F ac).

Equipped with these functions, anAsTRa content formalism can be used quiteflexibly. For entries to a knowledge base, developers can decide if a consistencycheck or forward reasoning is appropriate, and for queries, they can choose betweenretrieval of explicit contents and derivation of implicit contents.

However, in order to be logic-based in a theoretical sense, correspondence toFOPC must be achieved: It must be possible to translateLF expressions into FOPCformulas (syntactical correspondence), and`F must not exceed FOPC entailment.Hence, we define alogic-based content formalismF as a triple〈LF , tF ,`F 〉 with:

– LF is thelanguageof F .

250 WOLFGANG POHL

– tF is a translation functionthat translates assumption contentsac ∈ LF intoFOPC formulas:tF (ac) ∈ LFOPC. When applied to assumption type know-ledge bases KBAT , it translates allF -expressions of KBAT :

tF (KBAT ) := {tF (ac)|ac ∈ (KBAT ∩LF )}– Thederivation relation`F must be sound with respect to FOPC:

KBAT `F ac H⇒ tF (KBAT )|= tF (ac) (2)

where|= is the entailment relation of FOPC.When speaking about translation, we will also use the notationτ(ac) instead

of tF (ac). τ is a generic translation function that is instantiated depending on theformalism its argument belongs to. Thus,τ(KBAT ) is a complete FOPC transla-tion of KBAT . With this notation, it becomes easier to deal with assumption typeknowledge bases as a whole, which is needed for dealing with a fullAsTRa system.

From this general point of view on assumption types, the soundness requirement(2) for content formalisms can be re-expressed as follows:

KBAT `F ac H⇒ τ(KBAT )|= τ(ac).

This requirement is not stronger than (2), since the condition part of the implicationhas not changed. However, when we consider completeness (i.e., by looking at thereverse direction of the implication), things are different. If

KBAT `F ac⇐H τ(KBAT )|= τ(ac)

actually holds, F will take all assumption contents into account, regardless ofthe formalism in which they are represented. We call such a formalismideallylogic-based. In Section 5.3, we will present a result concerning the equivalence ofbasicAsTRa mechanisms and modal logic, which requires this property of contentformalisms10.

5.2. FLEXIBLY USING AN ASTRa SYSTEM

Before focusing on the theoretical aspects of theAsTRa framework, we will in-troduce means for practically using anAsTRa system. The main components havebeen described, namely assumption types (with stereotypes) and formalisms forassumption contents. These facilities permit the representation ofAT : ac type-internal expressions. So far, anAsTRa system consists of

10 This is a strong requirement, since it forces reasoning procedures of a content formalism to takeall contents of an assumption type into account. It is much more plausible that a content formalismF will have inference mechanisms that are equivalent to FOPC as long as onlyF expressions areconcerned. In (Pohl, 1997), we call such a formalismF -ideally logic-basedand obtain an equivalenceresult that is weaker but still useful.


– a user modeling knowledge base (UMKB)11 with a setAT of assumptiontypes and a setS of stereotypes, and

– a setF of content formalisms.

Now let us look at the UMKB access and reasoning facilities ofAsTRa.

5.2.1. UMKB access inAsTRa

In Section 4.4, we argued that tell and ask functions for knowledge base access witha set of standard sub-functions satisfy the most important demands of logic-baseduser model reasoning. TheAsTRa framework therefore specifies two functions,tellandask, for entries and queries toAsTRa user modeling knowledge bases. Thesefunctions will make use of the functionsstore and fetch for data-base-like entryand retrieval, and will employ the inference functionsderivable, forward , andconsistent(cf. Section 4.4) for reasoning purposes.

As theAsTRa framework is aimed at user modeling shell systems, it has beendesigned for flexibility. As far as reasoning is concerned, flexibility results fromthe introduction ofreasoning levels. The idea is that the behavior of the reasoningfunctions derivable, forward , and consistent determines the overall reasoningbehavior of anAsTRa system. Hence, if it is possible to choose from differentimplementations of these functions, it is possible to change the reasoning behaviorof an AsTRa system. We introduce areasoning levelL as a triplet of reasoningfunctions〈 derivableL, forward L, consistentL〉. Tell and ask will carry a para-meter that enables us to determine the reasoning level for each user model entry orquery as needed. TheAsTRa tell andask functions are defined as follows:

tell(L,UMKB , AT : ac) :=if consistentL(UMKB, AT : ac) then

store(UMKB, AT : ac) andforward L(UMKB, AT : ac)ask(L,UMKB, AT : ac) :=

fetch(UMKB, AT : ac) or derivableL(UMKB, AT : ac)

That is, an entry into a UMKB will be made if it is consistent with the cur-rent UMKB; in this case, forward inferences will also be performed, based on theexpression entered. A query is answered by looking up the queried expression inthe UMKB and, if not successful, trying to derive the expression. The amount ofreasoning involved is determined by specifying a reasoning levelL as the firstparameter, which controls reasoning level selection.

Note that there is no level indexL attached to the data base functionsstore andfetch, so their behavior is not influenced by the level parameter.

11 In principle, a user modeling shell that is built according to theAsTRa framework may maintainseveral UMKBs in order to support multiple users. To be in accordance with our single-UMKBdefinition, such a system need only have one designated current UMKB at any point in time.

252 WOLFGANG POHL

5.2.2. Basic Reasoning Levels

The only inference functions mentioned so far have been the reasoning functionsof content formalisms. These form the standard level for type-internal reasoningin an AsTRa system. However, there is already another reasoning level: the ‘noreasoning’ level. Reasoning can be avoided entirely by using reasoning level 0,which is defined as follows:

– derivable0(UMKB, AT : ac) := false– forward 0(UMKB, AT : ac) := true– consistent0(UMKB, AT : ac) := true

Note thattell andaskare defined as logical combinations of their sub-functions.So, at reasoning level 0,tell collapses tostore, andask collapses tofetch.

The only alternative to reasoning level 0–given the means described so far–is to employ the type-internal reasoning functions of content formalisms. Thus, asecond reasoning level can be defined. Its functions pick the assumption contentac

from anAsTRa expressionAT : ac and access the assumption type knowledge baseKBAT . For this purpose, the functions of the appropriate content formalismF(ac)

are employed. That is, this level is confined to reasoning within one assumptiontype. Hence, it is labeledT I , which is short for ‘type-internal’.

– derivableT I (UMKB, AT : ac) := derivableF(ac) (KBAT , ac),– forward T I (UMKB, AT : ac) := forwardF(ac) (KBAT , ac),– consistentT I (UMKB, AT : ac) := consistentF(ac) (KBAT , ac)

5.3. BASIC ASTRa AND MODAL LOGIC

So far, theAsTRa framework and its notions constitute an abstract and formalizedperspective on the partition approach. At first glance, this appears to have no impactconcerning our goal of fusing partitions with modal logic. So far, the main benefitof AsTRa is that several representation formalisms may be used within partitions(i.e., assumption types). However, the formal specifications made above will enableus to characterize the basicAsTRa mechanisms in terms of modal logic. On thisfoundation, the integration of modal logic with the basic mechanisms is possible.

First, a syntactic relationship exists between theAT : ac expressions ofAsTRaand modal logic formulas. A notation for the latter was introduced in Section 2.3.2.Recall that a modal operator has the form2(m,a), with m being a modality (likeBfor belief,W for wants/goals, etc.) anda being an agent (e.g., the userU ). Thesyntactical relationship is quite obvious: An assumption type label

AT = a1m1 . . . anmn

is a sequence of agent-modality pairs, which corresponds to a sequence of modaloperators with modality and agent indices

M(AT ) := 2(m1,a1) . . .2(mn,an)


Furthermore, any assumption contentac has a corresponding FOPC expressionτ(ac). Hence, a type-internal expressionAT : ac corresponds to a modal logicformulaM(AT ) τ(ac) (cf. Section 2.3.2). E.g., theAsTRa expression

SBUW: attacks(flipper, shark56)

(i.e., the FOPC assumption contentattacks(flipper,shark56) of typeSBUW) corres-ponds to the modal formula

2(B,S)2(W,U) attacks(flipper, shark56).

The modal logic that syntactically permits only suchM(AT ) τ(ac) formulas iscalled assumption logic(AL). Assumption type knowledge bases KBAT can berepresented by sets ofAL formulas, KBALAT :

KBALAT := {M(AT ) τ(ac)|ac ∈ KBAT }.The union of all sets KBALAT is a reformulation of the whole UMKB asAL formulasand will be called UMKBAL:

UMKBAL :=⋃

AT ∈AT

KBALAT .

AL is a normal, multi-modal, multi-agent logic with a restricted formula syntax.Assuming a standard possible worlds semantics (Kripke, 1963), axiom K and hencealso modal modus ponens hold for any possible operator2(m,a) of AL:

2(m,a)(8→ 9)→ (2(m,a)8→ 2(m,a)9) (K)

2(m,a)8 ∧2(m,a)(8→ 9)→ 2(m,a)9 (modal modus ponens)

This logic is not only syntactically related toAsTRa, but also semantically. Itcan be proven that reasoning within assumption types, i.e. reasoning on the level ofcontent formalisms, is in line with the semantics ofAL (for a proof of the followingtheorem, see Pohl, 1997b):

THEOREM 1. If all content formalisms of anAsTRa system are ideally logic-based, then type-internalAsTRa reasoning is sound and complete with respect toassumption logic:

derivableT I (UMKB, AT : ac) = true⇐⇒ UMKBAL|=M(AT ) τ(ac).

254 WOLFGANG POHL

5.4. MODAL LOGIC REASONING ADDED TO ASSUMPTIONTYPES

With the basicAsTRa mechanisms, different types of assumptions can be rep-resented, and assumption contents can be expressions of logic-based formalisms.However, possible assumption types are of a positive nature only: assumptionsabout what the userdoesbelieve, want, etc. are allowed, but not assumptionsabout what the userdoes notbelieve, want etc. Furthermore, assumption typesare isolated; neither relationships between contents of different types nor gen-eral relationships between assumption types can be expressed. Although the basicAsTRa mechanisms satisfy the representational and inferential needs of many usermodeling systems, we want to enable the developer of a user modeling systemto express relationships between assumption types as well as negative assump-tions.

In the previous subsection, we described the correspondence between (type-internal) contents of anAsTRa knowledge base and formulas ofAL, which is arestricted version of a multi-modal, multi-agent logic. Using the full logic, whichwe will call AL+, both negative assumptions and type-external relationships (cf.Section 2.3.2) can be represented. Since they provide the full expressive power ofmodal logic,AL+ formulas, including formula schemes (also called axioms), shallbe allowed in anAsTRa system. We therefore define that, beyond assumption typesand stereotypes with assumption contents, anextendedAsTRa UMKB may containa set of modal formulasMF and a set of modal axiomsMA.

Because of the correspondence between type-internal UMKB contents and themodal logicAL, all UMKB contents can be expressed in the modal logicAL+.More precisely, for an extendedAsTRa UMKB, there is a corresponding set ofAL+ formulas, UMKBAL

+, with

UMKBAL+ :=( ⋃AT ∈AT

KBALAT

)∪MF ∪MA.

Hence,AsTRa reasoning could be completely based onAL+ reasoning functions,applied to UMKBAL

+. However, with modal logic reasoning only, type-internal

AsTRa reasoning with its flexibility of allowing several formalisms for assumptioncontents would be abandoned. This would be especially disadvantageous whenevermost parts of the UMKB could be represented within assumption types using spe-cialized formalisms, and most reasoning tasks could be performed type-internallyusing the possibly optimized facilities of these formalisms.

For these reasons, the basic mechanisms are preserved. In theAsTRa frame-work, modal logic reasoning is regarded as an additional reasoning level, the reas-oning functions of which operate on the full UMKB in itsAL+ form. This reas-oning level is also calledAL+. In order to implement theAL+ level, mechan-isms for derivability and consistency checking as well as forward reasoning areneeded. That is, ifAL+ reasoning functionsAL+-derivable, AL+-forward, andAL+-consistentare available, each of them operating on anAL+ knowledge base


and anAL+ formula φ, the reasoning levelAL+ can be realized. Its functionsoperate on a UMKB (including the setsMF andMA) and either anAsTRa ex-pressionAT : ac or anAL+ formulaφ. They invoke the appropriateAL+ reasoningfunctions on UMKBAL

+and either the correspondingAL formulaM(AT ) τ(ac)

or theAL+ formulaφ as is:

derivableAL+(UMKB , AT : ac):= AL+-derivable(UMKBAL+,M(AT ) τ(ac))

derivableAL+(UMKB , φ) := AL+-derivable(UMKBAL+, φ)

forward AL+(UMKB , AT : ac):= AL+-forward(UMKBAL+,M(AT ) τ(ac))

forward AL+(UMKB , φ) := AL+-forward(UMKBAL+, φ)

consistentAL+(UMKB , AT : ac):= AL+-consistent(UMKBAL+,M(AT ) τ(ac))

consistentAL+(UMKB , φ) := AL+-consistent(UMKBAL+, φ).

Note that with the introduction ofAL+ into AsTRa, the level-independent func-tionsstoreandfetch need to be modified slightly to takeAL+ formulas as possibleinputs totell andask into account.

With the availability of theAL+ reasoning level, an extendedAsTRa imple-mentation can offerAL+ reasoningas an additional option. This means that thefull expressive power of modal logic becomes available without sacrificing theflexibility of AsTRa, especially that of its basic mechanisms.

In order to make its internal mechanisms transparent to the user model de-veloper, an extendedAsTRa implementation may admitAL+ as a uniform interfacelanguage for UMKB contents, thus permitting top-down access to the UMKB as analternative to standard bottom-up access. This requires that simpleAL expressionsof the formM(AT ) τ(ac) can be detected and, if desired, can be handled in thesame way as their corresponding basicAsTRa expressionsAT : ac. Essentially, thistop-down approach was pursued by the user modeling shell BGP-MS as describedby Kobsa and Pohl (1995).

5.5. NEGATIVE ASSUMPTIONTYPES

In the previous subsection, we mentioned that negative assumptions can be repres-ented as formulas of the modal logicAL+. The following formula is a concretenegative assumption example:

2(B,S)¬2(B,U) dangerous(dolphin21), (3)

256 WOLFGANG POHL

states that the user is assumed not to believe that the object ‘dolphin21’ is classi-fied as dangerous. For several reasons, it is worth taking a closer look at negativeassumptions. First, there is a syntactic issue with such formulas: They differ fromsimpleAL formulas, which correspond to type-internal knowledge, only in thenegation operator that may appear in front of modal operators. We will useAL¬to refer to this negative assumption subset ofAL+. Second, and more important,negative assumptions constitute an interesting subclass of user modeling know-ledge. Several user modeling systems have used negative assumptions withoutneeding any other type-external representation or reasoning methods (e.g., seeHuang et al., 1991, Kobsa et al., 1994, and Pohl et al., 1995). Hence, it makessense to deal with negative assumptions in a specialized way. Because of the simil-arity between negative assumptions and type-internal knowledge, such a method islikely to be closely related to type-internal mechanisms. However, because negativeassumptions can be expressed in modal logic, special treatment mechanisms willbe soundly based on modal logic semantics.

Like positive assumptions, which are handled by the basicAsTRa mechanisms,negative assumptions will be organized into assumption types. By using the neg-ation symbol∼ in assumption type labels, we can introduce negative assumptiontypes like SB∼UW (assumptions about what is not a user goal) etc. Then, For-mula 3 corresponds to the type-internal expressionSB∼UB:dangerous(dolphin21).

Note that anAsTRa expression SB∼UB:p is not equivalent to the expressionSBUB:¬p. The first case represents a negative assessment of S concerning a be-lief of U, while the second case represents an assumption about a negative as-sessment of U concerning a fact denoted byp. However, there are relationshipsbetween such differently negated expressions. In this section, we will develop in-ference mechanisms which are based on modal logic semantics and exploit theserelationships.

The reader may ask why we introduce negative assumption types apart fromthe other, “positive”AsTRa assumption types. There is an important reason forhandling negative types separately: Due to the modal logic semantics of negat-ive assumptions, type-internal reasoning as defined for standard assumption typescannot be applied to negative types. For positive types, if an assumption typeknowledge base entails a content expression, KBAT |= ac, an entailment will alsohold for the correspondingAL expressions: KBALAT |= M(AT ) τ(ac). For negativeassumption types andAL¬, thisentailment correspondencedoes not exist. In termsof modal logic:φ |= ψ is not equivalent to¬2(m,a)φ|= ¬2(m,a)ψ (while it isequivalent to2(m,a)φ |= 2(m,a)ψ , which is the formal background of the entailmentcorrespondence in the case of positive assumption types).

Since the general approach of type-internal reasoning does not apply to negativeassumption types, we have invented specialized reasoning methods for dealing withnegative assumptions. In modal logics, one of the classical characterizing axiomsis the axiom D:

2φ→ ¬2¬φ (D)


D is often taken to be characteristic of logics of belief. In this case, it says that ifsomething is believed, its converse (in terms of formal logic: its negation) is notbelieved. D obviously allows for inferences that involve negated modal operators.In our reasoning procedures for negative assumptions, we take advantage of this.That is, these procedures are based on the central assumption that, withinAsTRa,axiom D holds12.

Now our task is to specify inference procedures which efficiently imitate modallogic reasoning that is based on axiom D. For this purpose, we will make use of the‘diamond’ operator3 of modal logic. This operator can replace negated2 (‘box’)operators, since3φ ≡ ¬2¬φ holds. Using3, anyAL¬ formula can be writtenwithout negations in front of modal operators. For example:

2(B,S)¬2(W,U) φ ≡ 2(B,S)3(W,U)¬φWe will call such a negation-free formbox-diamond form, short BDF. The BDF ofa negative assumption inAT : ac form is defined as the BDF of its correspondingAL¬ formula M(AT ) τ(ac). The example shows that transformation into BDFmay require negation of assumption contents.

BDF is the basis for an automated application of the D axiom. Using the dia-mond operator, D can be rewritten as

2φ→ 3φ.From this axiom, it can be derived that similar axiomatic implications also hold forBDF formulas with more than one operator. For BDF forms with two operators,all valid implications are22φ → 2 3φ, 32φ → 3 3φ, 23φ → 3 3φ, and22φ→ 33φ. The common property of all these axioms is that the conclusion isobtained by replacing at least one2 operator of the antecedent with a3 operator.This observation can be generalized to operator sequences of any length, so thatwe obtain the following proposition as a corollary from D:

COROLLARY 1. If axiom D holds for all modal operators ofAL¬ (i.e.,2(m,a)φ→3(m,a)φ holds for allm, a), then

O1(m1,a1)O2(m2,a2) . . . On(mn,an)φ→ O ′1(m1,a1)O ′2(m2,a2)

. . . O ′n(mn,an)φ

holds, whereO ′i = 3 if Oi = 3, andO ′i ∈ {2,3} if Oi = 2. In other words,

O1(m1,a1)O2(m2,a2) . . . On(mn,an)φ

entails all formulas

O ′1(m1,a1)O ′2(m2,a2)

. . . O ′n(mn,an)φ

12 I.e., in order to be consistent with negative type reasoning,AL+ reasoning must operateaccording to axiom D.

258 WOLFGANG POHL

that satisfy the above conditions onO ′i.

Note that in case ofAsTRa, the first operator of anAL¬ formula must be2(B,S),so that additionallyO ′1(m1,a1)

= O1(m1,a1) = 2(B,S) holds.In sum, axiom D leads to a family of entailments involving BDF formulas. In

order to apply them to negative assumptions, one needs to form the BDF of theAT : ac form, apply the above corollary, and re-transform the result into a type-internal expression (viaAL¬). An example:

(type-internal expression) SBMB∼UB : dangerous(dolphin21)

(AL¬ correspondence) ≡ 2(B,S)2(B,M)¬2(B,U) dangerous(dolphin21)

(BDF transformation) ≡ 2(B,S)2(B,M)3(B,U)¬ dangerous(dolphin21)

(Corollary 1) |= 2(B,S)3(B,M)3(B,U)¬ dangerous(dolphin21)

(BDF retransformation) ≡ 2(B,S)¬2(B,M)2(B,U) dangerous(dolphin21)

(type-internal expression) ≡ SB∼MBUB : dangerous(dolphin21)

Note that these steps did not manipulate the assumption content besides negat-ing and de-negating it. Based on this observation, we can improve the efficiency ofnegative assumption reasoning. The above example illustrates that the entailment

SBMB∼UB: ac |= SB∼MBUB: ac,holds for all assumption contentsac. This is the only implication that can becomputed for assumption type SBMB∼UB. Hence, we obtain the relationship

forward(SBMB∼UB) = {〈SB∼MBUB, ε〉}which reads “from any type-internal expression SBMB∼UB:ac, we can derive (ina forward-directed way) the expression SB∼MBUB:ac”. The second componentof the pair〈SB∼MBUB, ε〉 (the “empty word”ε) indicates that the assumptioncontent remains non-negated. In contrast, for assumption type SBUW we get

forward(SBUW) = {〈SB∼UW,¬〉}.Similarly, also derivable and inconsistent relationships can be established (see

Pohl, 1997b, for details). They can be employed by reasoning functionsforward NA,derivableNA, andconsistentNA, which together form a reasoning levelNA fornegative assumptions. For instance,forward NA (UMKB, AT : ac) works as spe-cified in Figure 4: For every assumption type which is the first element of a pairfrom forward(AT ), type-internal forward reasoning is done. The second elementof each pair determines whetherac will be processed in negated form or as is.


Figure 4. Reasoning with negative assumption types:forwardNA.

Figure 5. Negative assumption inference relationships.

Figure 5 illustrates the inference relationships used for reasoning levelNA,considering assumption types SBUW and SB∼UW. From any assumption contentp in type SBUW, its negation¬p can be inferred in type SB∼UW (see above).Conversely, the negation of any content of SB∼UW is derivable in SBUW. Incon-sistencies exist between unmodified contents of SBUW and SB∼UB: SBUW:p isinconsistent with SB∼UW:p, and SBUW:¬p is inconsistent with SB∼UW:¬p.

5.6. ASTRa: POWERFUL AND FLEXIBLE

With AsTRa, we have specified a framework for logic-based user model represent-ation and reasoning. Its main characteristics are:

representation and reasoning power:AsTRa is based on the assumption type /assumption content dichotomy for user model contents that we proposed inSection 2.1. Hence, the basic mechanisms of anAsTRa system are assumptiontypes as partial user models (possibly including stereotype knowledge bases)and logic-based formalisms for handling assumption contents. These basicelements can be characterized in terms of modal logic, both syntacticallyand semantically. Consequently, full modal logic reasoning has been addedto and integrated with the basic mechanisms. As a third, intermediate option,special inference mechanisms for negative assumptions have been defined,again firmly grounded in modal logic semantics.

flexibility of deployment: An AsTRa system can offer a variety of choices foruser model representation (type-internal expressions with different contentformalisms, and modal logic) and reasoning (four different reasoning levels).All these facilities are directly accessible to the user of anAsTRa system ina bottom-up fashion. This is especially beneficial for user modeling shell

260 WOLFGANG POHL

systems because they may offer the full arsenal ofAsTRa features, whileallowing user model developers with less sophisticated needs to make useof an appropriate subset of possibilities.

A fundamental achievement of theAsTRa framework is the reconciliation ofthe partition approach and the modal logic approach to user modeling, based ona modal logic semantics for the well-defined, partition-like assumption type ap-proach. The flexibility ofAsTra was achieved by using a bottom-up approach tothe integration of partitions and modal logic.

6. AsTRa and BGP-MS

The BGP-MS user modeling shell system has been under development for a longtime. Modeling of terminological knowledge (with the formalism SB-ONE) ofthe user as well as system domain knowledge within partition hierarchies and astereotype management system were its earliest features (Kobsa, 1990). Later itwas extended to represent fact- and rule-like knowledge via FOPC and to allow forrepresentation of the user’s goals; moreover, its implementation was enhanced byseveral graphical user interfaces for developers of user modeling systems (Kobsa& Pohl, 1995). Possible extensions using modal logic representation and reasoningwere investigated (Kobsa, 1992) and developed (Pohl, 1996) for BGP-MS.

There is a mutual relationship betweenAsTRa and BGP-MS: The work onAsTRa started as an effort to formalize the representation and reasoning features ofBGP-MS, but soonAsTRa became a more general representation framework. BGP-MS then was extended to fit this framework, particularly by developing bottom-upaccess facilities as prescribed byAsTRa.

In this section, we will describe BGP-MS as an example implementation of theAsTRa framework. Partitions are used to implement assumption types (includingnegative types), and SB-ONE and FOPC become content formalisms. Moreover,the implementation ofAL+ reasoning in BGP-MS is touched on. The sectionconcludes with an example of the use of BGP-MS as anAsTRa implementation.

6.1. PARTITION HIERARCHIES AND ASSUMPTION TYPES

The partition mechanism KN-PART (Scherer, 1990; Fink & Herrmann, 1993) waschosen as the foundation of theAsTRa implementation within BGP-MS. The parti-tions of KN-PART are very close to assumption types, since they basically make itpossible to store a set of content items. In principle, partition contents can be arbit-rary data. KN-PART internally employs a database mechanism that offers functionsfor entry and retrieval. These facilities must be used by content formalisms for theimplementation ofstoreF andfetchF functions.

KN-PART allows for the definition of partition hierarchies with the built-ininference mechanismsinheritanceandpropagation. Common contents of all sub-ordinate partitions of a partitionP will be propagated toP when a new entry


Figure 6. Assumption types and stereotypes in a partition hierarchy.

into one of the subordinate partitions is made. Conversely, subordinate partitionsinherit the contents of superordinates at the time of retrieval. That is, in a retrievalsituation, the contents of a set of partitions are accessed. Such a set of partitionsis calledview. Seen from the outside, views are the central storage entities of apartition hierarchy. Hence, in BGP-MS assumption types were implemented asviews.

More formally, a partitionP is regarded as knowledge base KBP . The viewthat corresponds to a partition,V (P ), is a set of partitions{P,P1, . . . , Pn}, withP1, . . . , Pn being all direct and indirect superpartitions ofP . We can then define aview knowledge base KBV (P ) as the union of all partition knowledge bases KBP ′with P ′ ∈ V (P ):

KBV (P ) :=⋃

P ′∈V (P )KBP ′ .

In BGP-MS, a partitionPAT is established for each assumption typeAT . Theassumption type knowledge base KBAT is then defined as the corresponding viewknowledge base KBV (PAT ).

There is one important consequence of assumption types being implementedusing KN-PART: Hierarchical relationships between assumption types can be in-troduced in BGP-MS via KN-PART partition hierarchies. This possibility goesbeyond theAsTRa framework, but does not violate its definitions. Through theuse of view knowledge bases, we can soundly define assumption type knowledgebases in BGP-MS.

A small BGP-MS assumption type hierarchy is shown on the left in Figure 6.Three assumption types are present, namely SB, SBUB, and SBMB. Correspond-ingly, three partitions have been established:PSB , PSBUB , and PSBMB (brieflylabeled SB, SBUB, and SBMB, as well). The plain arrows indicate that SBMBis a superpartition of both SB and SBUB. Hence, the views of this hierarchy areV (SB)= {SB, SBMB}, V (SBUB)= {SBUB, SBMB}, andV (SBMB)= {SBMB}.Note that, in this example, the mutual belief type SBMB is defined to contain theshared beliefs of system (SB) and user (SBUB).

262 WOLFGANG POHL

The second consequence of using KN-PART partition hierarchies is a quitestraightforward implementation of stereotypes. Recall that theAsTRa frameworkdefines a stereotypeS to be a set of pairs

S = {〈KBS1, AT1〉, . . . , 〈KBS

n, ATn〉}

where KBSi is a (stereotype) knowledge base andATi is its associated assump-tion type. In BGP-MS, each stereotype knowledge base KBS

i is represented bya stereotype partitionPSi and its partition knowledge base. Obeying theAsTRadefinition, each stereotype partition is associated with an assumption typeATi , i.e.in BGP-MS: a partitionPATi .

If a stereotype applies to the current user, the contents of stereotype parti-tions must be added to the appropriate assumption type knowledge bases. In thiscase, each stereotype partitionPSi will become a superordinate partition of thecorresponding assumption type partitionPATi . Thus, the assumption type view isextended by the stereotype partition:V (PATi ) := V (PATi )∪PSi . Consequently, theassumption type knowledge base will automatically comprise the contents of thestereotype partition at the time of subsequent retrieval operations.

In BGP-MS, a stereotype is introduced by defining a new stereotype name andlisting the set of assumption types that the stereotype partitions are to be associatedwith. Then, stereotype partitions will be created automatically; their partition labelsare generated from the corresponding assumption type labels by replacing eachoccurrence of U with the stereotype name. For instance (let the modality I standfor ‘interests’), if a stereotype ‘novice’ is defined to be related to assumption typesSBUB and SBUI, two stereotype partitions are created and labeled SBnoviceB andSBnoviceI. Thus, anAsTRa stereotype

novice= {〈KBSBnoviceB,SBUB〉, 〈KBSBnoviceI,SBUI〉}

is introduced into the current UMKB.The implementation of thisAsTRa stereotype in a BGP-MS partition hierarchy

is illustrated in Figure 6. Besides the ‘novice’ stereotype, there is an ‘expert’ ste-reotype with only one stereotype partition. This partition is to contain SBUB as-sumptions and is therefore labeled SBexpertB. The dashed arrows indicate thathierarchy links will be established between stereotype partitions and their relatedassumption type partitions, when their stereotype is activated. In case of stereotyperetraction, these links will be removed.

6.2. CONTENT FORMALISMS

6.2.1. SB-ONE

SB-ONE is a conceptual knowledge representation system, which loosely fits intothe KL-ONE paradigm (Brachman & Schmolze, 1985). Hence, its main represent-ation elements are concepts and attribute descriptions (‘role descriptions’ in terms


Table III. LSB-ONEexpressions and their FOPC translations.

LSB-ONE descr. logic FOPC translation

(:isa C C′) C v C′ ∀xC(x)→ C′(x)(:isa C (:and C1 . . . Cn)) C v C1 u . . . u Cn ∀xC(x)→ C1(x) ∧ . . . ∧ Cn(x)(:isa C (:all R C′)) C v ∀R.C′ ∀x, yC(x) ∧ R(x, y)→ C′(y)(:concept C) C v thing ∀xC(x)→ thing(x)

Figure 7. SB-ONE concept taxonomy.

of KL-ONE). Recall that, semantically, concepts are sets of objects, and roles arebinary relations between objects (i.e., sets of object pairs).

In BGP-MS, only a subset of the whole range of SB-ONE constructs is em-ployed, which comprises standard constructs of modern terminological formal-isms, namely description logics. In these logics, there are mainly two kinds ofexpressions: concept terms and concept definitions. LetC denote a concept, andlet CT be a possibly complex concept term. Then a (partial) concept definitionis writtenC v CT (read:C is a subset of the concept that is specified byCT ).Concept terms can be formed, e.g., by concept symbolsC, conjunctionsC1 u C2

(the intersection of conceptsC1 andC2) and role-value-restrictions∀R.C (the setof objects that are related via roleR to objects ofC only). It is important to notethat concept definitions using these terms can be equivalently translated into FOPC.

All the above description logic expressions have corresponding constructs inSB-ONE. For BGP-MS, we restricted the use of SB-ONE to concept definitionsthat involve those constructs only. In addition, we defined an interface language toSB-ONE constructs,LSB-ONE, as it is required by theAsTRa framework. Possibleexpressions ofLSB-ONEare listed in Table III, together with corresponding expres-sions of description logic (in the middle column) and their translations into FOPC(in the right column). These translations lead to a translation functiontSB-ONE. So,SB-ONE, as it is used in BGP-MS, becomes a logic-based formalism.C,C ′, Ci ,andR stand for concept and role symbols, respectively. The special conceptthingdenotes the set of all possible objects; it is present in any SB-ONE knowledge base.

264 WOLFGANG POHL

An example SB-ONE concept hierarchy is shown in Figure 7. On the left, thetypical graphical notation of KL-ONE systems is used. Ovals denote concepts, andarrows denote concept subsumption (ISA links). On the right, the correspondingLSB-ONEexpressions are listed.

There are several built-in inferences in SB-ONE, mainly based on the inheri-tance and transitivity property of subsumption links. For example, assume(:isa C1

(:all RC2)) (i.e., there is a conceptC1 with an attribute relationR that is value-restricted to a conceptC2). If (:isa C3 C1) (C3 is subsumed byC1) also applies,thenC3 inherits attributeR together with its value restriction. Furthermore, if(:isaC4 C3), SB-ONE will infer that implicitly(:isa C4 C1).

However, SB-ONE does not immediately permit us to establish the fine-grainedset of access functions that theAsTRa framework requires of content formalisms.For all of its representational constructs, SB-ONE offers definition and retrievalfunctions that can be used to enter the construct into a given knowledge base orto query whether the construct is (perhaps implicitly) contained in the knowledgebase. In many cases, these functions do not allow us to decide whether forward orbackward inferences will take place or not. That is, from SB-ONE, we obtain onlytwo basic access functions, namelySB-ONE-tellandSB-ONE-ask. However, thesecan be used to emulate the full set ofAsTRa knowledge base access functions forcontent formalisms as follows:

– storeSB-ONE(KBAT , ac) := SB-ONE-tell(KBAT , ac)

– forwardSB-ONE(KBAT , ac):= SB-ONE-tell(KBAT , ac)

– consistentSB-ONE(KBAT , ac):= true

– fetchSB-ONE(KBAT , ac):= SB-ONE-ask(KBAT , ac)

– derivableSB-ONE(KBAT , ac):= SB-ONE-ask(KBAT , ac)

The consequence of this emulation is that for type-internal handling of SB-ONEexpressions, the reasoning levels 0 andTI are identical.

6.2.2. First-Order Predicate Calculus with OTTER

In BGP-MS, FOPC representation and reasoning was implemented using a systemcalled KN-OTTER, which augments the theorem prover OTTER (McCune, 1994)with an inter-process communication interface. Thus, BGP-MS can invoke OTTERfor FOPC reasoning tasks and provide necessary information via this interface.

In terms ofAsTRa, FOPC is a content formalism. As such, it defines a lan-guageLFOPC. This language employs a text-oriented notation of standard FOPCsyntax, with&, |, and− as conjunction, disjunction, and negation operators, with-> and<-> as (co-)implication operators, and withall andexists as universal andexistential quantifiers. Table IV shows a syntax definition ofLFOPC; beyond thisdefinition, formulas must bind all their variables with quantifiers.


Table IV. Syntax ofLFOPC

<formula> ::= predicate[(<term> {,<term>}+)]| <formula> { & <formula> }+| <formula> { | <formula> }+| <formula> -> <formula>| <formula> <-> <formula>| −<formula>| all variable+ <formula>| exists variable+ <formula>

<term> ::= variable | function[(<term> {, <term>}+)]

An exampleLFOPC formula13 is

all x y dangerous(x) & hero(y) --> attacks(y, x).

As a resolution-based theorem prover, OTTER finds refutation proofs, i.e., it de-tects inconsistencies in formula sets. The KN-OTTER system essentially providesa boolean-valued functionkn-otter(U, S) that takes two setsU andS of FOPCformulas and returns true if and only if there is an inconsistency in the setU ∪ S.This set is split into two subsetsU andS, because OTTER employs the ‘set ofsupport’ proof strategy which assumes that the setU is consistent, and concentrateson the ‘set of support’S to find an inconsistency. Through different choices ofS

andU , OTTER can be used to perform different reasoning tasks.This feature was utilized to implement the reasoning functions of theAsTRa

content formalism FOPC within BGP-MS. Recall that in standard logics, a formulaf follows from a formula setK (K |= f ), if and only ifK ∪ {¬f } is inconsistent.Hence, the functionsderivableFOPC andconsistentFOPC are defined as follows:

derivableFOPC(KBAT , f ) := kn-otter(KBAT , {¬f })consistentFOPC(KBAT , f ) := not(kn-otter(KBAT , {f })).

Forward reasoning with OTTER can be done in a way that is very similar toconsistency checking. Note that, in a resolution run, expressions are generated(the so-called resolvents) that logically follow from the given set of expressions.Thus, if thekn-otter function is extended to return not only a boolean value, butalso the generated resolvents,forwardFOPC can make the same call tokn-otterasconsistentFOPC. Schauer and Pohl (1997) describe the implementation of such anextension, which we callkn-otter*. With kn-otter*, we can define:

forwardFOPC(KBAT , f ) := kn-otter*(KBAT , {f })13 The intended meaning of this formula will be explained in Section 6.5.

266 WOLFGANG POHL

SincestoreFOPC and fetchFOPC do not involve reasoning, they can be realizedwithout kn-otter. They simply manipulate the assumption type knowledge base:

storeFOPC(KBAT , f )addsf to KBAT

fetchFOPC(KBAT , f ) := f ∈ KBAT .

By definition, anAsTRa content formalism must be logic-based and, hence,correspond to a subset of FOPC. Therefore, full first-order logic is the most power-ful content formalism possible within anAsTRa implementation. This remark alsocharacterizes the relationship between the content formalisms SB-ONE and FOPC.All SB-ONE assumption contents can be translated to FOPC and hence integratedinto FOPC reasoning. This might be useful when SB-ONE assumption contentsare related to FOPC assumption contents within the same assumption type. Forinstance, instantiations of SB-ONE concepts or roles may be contained in theFOPC part of an assumption type knowledge base. In order to allow this kind ofmixed representation, KN-OTTER was enhanced to take SB-ONE knowledge intoaccount within a refutation process. It was enabled to recognize situations in theresolution process in which a query to the SB-ONE part of a view may be bene-ficial (Zimmermann, 1994). This mechanism was based on the FOPC equivalencepatterns of SB-ONE constructs (cf. Table III).

6.3. AL+ REASONING IN BGP-MS

In Section 5.3, we explained that the basicAsTRa mechanisms, i.e., assumptiontypes and content formalisms, syntactically and semantically correspond to thesimple modal logicAL. Due to this correspondence, the basic mechanisms couldbe extended to reasoning mechanisms that process expressions of the full modallogicAL+. With AL+, negative assumptions and both specific and schematic rela-tionships between assumptions of different types can be expressed.

Kobsa and Pohl (1995) gave an approach to implementing modal logic reason-ing in BGP-MS. Since an FOPC theorem prover was already available in BGP-MS,they suggested using techniques for translating modal formulas into semanticallyequivalent FOPC formulas and then applying standard FOPC reasoning. In par-ticular, functional translation (Ohlbach, 1991) and the SCAN algorithm (Gabbay& Ohlbach, 1992) were discussed as translation facilities for modal formulas andmodal formula schemes, respectively.

In Pohl (1996), we described how the use of these translation techniques couldbe optimized for BGP-MS. The main aspect of this optimization is that all con-tents of an assumption type (a view knowledge base in terms of BGP-MS) have astructurally identical translation. In a functionally translated formula, the semanticsof the modal operators of the original formula are expressed by so-called ‘worldterms’. Now recall that assumption type expressionsAT : ac correspond to modalformulasM(AT ) τ(ac). All AT : ac expressions of the same typeAT have the


same modal operator sequenceM(AT ) and therefore all of their functional trans-lations (i.e., the translations of their corresponding modal formulas) have the sameworld term (expressing the semantics ofM(AT )).

Hence, the world term of translatedAT : ac expressions only depends on theassumption typeAT and can be computed whenever a new type is introduced. Foreach assumption content, an empty ‘translation frame’ is constructed, into whichan assumption type world term can be inserted. Thus, the generation of functionaltranslations of the type-internal part of a BGP-MS UMKB is as follows: For everyassumption type, the world term of this type is inserted into the translation framesof all content expressions that are contained in the assumption type (i.e., view)knowledge base. If an assumption contentac is contained in more than one view,then it is part of several assumption type expressions. The procedure describedabove guarantees that translations are generated for all of these expressions.

6.4. NEGATIVE ASSUMPTIONTYPES

In the AsTRa framework, negative assumption types were introduced to handlenegative assumptions in a special way. In BGP-MS, a negative assumption type isimplemented like all assumption types: as a partition with a partition knowledgebase. In principle, such a “negative partition” does not differ from other partitions.It can be linked into a partition hierarchy and hence also to stereotype partitions.Both available content formalisms, SB-ONE and FOPC, can be used to representcontents of negative assumption types.

Reasoning with negative assumption types is based on the relations DERIV-ABLE, FORWARD, and INCONSISTENT introduced in Section 5.5. For a neg-ative assumption type, they exactly describe inferential relationships between con-tents of this type and contents of other types. Every assumption typeAT , which inBGP-MS is represented by a partitionPAT , is in DERIVABLE, FORWARD, andINCONSISTENT relation to fixed and finite sets of all possible other assumptiontypes. Hence, these sets need to be computed only once for each type.

An example: With the definition of the negative assumption type SB∼UB thefollowing sets are computed:

DERIVABLE(SB∼UB) = {〈SBUB,¬〉}FORWARD(SB∼UB) = ∅INCONSISTENT(SB∼UB) = {〈SBUB, ε〉}.

Thus, derivableNA(UMKB, SB∼UB: ac) will look for SBUB:¬ac in order toderive the query expression,forward NA(UMKB, SB∼UB: ac) will not infer any-thing, andconsistentNA(UMKB, SB∼UB:ac) will look for SBUB:ac in order tofind a contradicting UMKB content.

268 WOLFGANG POHL

Figure 8. A BGP-MS UMKB after development time.

Note that in this example,derivableNA negates the assumption contentac. Thisdemonstrates that specialized negative type reasoning is limited in case of SB-ONEassumption contents, since there is no negation operator inLSB-ONE.

6.5. USING BGP-MS

We want to conclude this section with an illustration of the application of BGP-MS as anAsTRa system in a coherent example. Some elements of this examplehave already been presented in previous sections where the examples were largelytaken from the domain of maritime animals. We will exploit this in our somewhatfuturistic application scenario: Imagine a modern home entertainment environmentwith interactive adaptive television. The TV system attempts to adapt broadcaststo characteristics of individual spectators (i.e., users). For this purpose, it employsBGP-MS to maintain a user modeling knowledge base that contains assumptionsabout user beliefs and preferences. It exploits the user model to adapt the utter-ances of actors to the assumed knowledge of the user about the domain, and toaccommodate events and actions according to what the user is assumed to preferto happen.

In the specific examples that are given below, the user is watching a broadcast ofthe ‘Flipper’ TV series, which was originally produced in the 1960s in the U.S.A.The hero of this series is Flipper, a tame dolphin. Flipper is able to attack sharks,which will play a crucial role in the example.

6.5.1. Development Time

At the development timeof a user modeling system, the user model structure forthe application domain is built, domain knowledge may be integrated into the user


modeling knowledge base, and rules and procedures for user model acquisition aredefined or implemented. In our example, the user model developer sets up a UMKBwith four main components (for an illustration of this UMKB, see Figure 8):

1. Assumption types are specified with calls like

(define-assumption-type ’SBUB).

In BGP-MS, a wide range of assumption types can be defined. By default,BGP-MS permits the use of the modality symbols B and W for beliefs andgoals (W is short for ‘wants’). In addition, the user model developer can intro-duce new modality symbols, like in

(add-modality ’Pref)

Using this modality, an assumption type SBUPref is defined in our example tocontain preferences of the individual spectator.

2. An SB-ONE concept hierarchy on animals, which was already presented inSection 6.2.1, is entered into the UMKB as domain knowledge that is stored inassumption type SB.

3. Two stereotypes are defined, namely ‘fl-adv’ and ‘action’, both of which haveonly one stereotype partition: SBfl-advB is associated with the SBUB assump-tion type and contains beliefs of advanced Flipper spectators; while SBaction-Pref is associated with SBUPref and contains specific preferences of spec-tators with a general preference for action. The pre-defined contents of thesestereotype partitions are as follows:

SBfl-advB contains terminological knowledge, among others the subsumption(:isashark dangerous). Here,dangerous is a concept, which denotes the class ofall dangerous objects (animals, in this case). In addition, there is a commonbelief among advanced Flipper spectators, which is represented by an FOPCformula:hero(flipper).

SBactionPref contains ‘preference rules’, which describe conditions for the userto prefer some action to happen. One such rule is:all x y dangerous(x) &hero(y) --> attacks(y, x) (cf. Section 6.2.2). It expresses the preference (of ac-tion fans) that heroes attack dangerous objects.

4. Finally, a modal formula scheme is specified14:

(2(B,S)2(B,U)8 ∧2(B,S)2(P ref,U)(8→ 9))→ 2(B,S)2(P ref,U)9This enables the system to infer preferences from preference rules, the condi-tions of which are satisfied by user beliefs. That is, if the user believes factsthat match the condition part of a preference rule, it can be inferred that she

14 As for FOPC formulas, BGP-MS offers an ASCII-character-based syntax also forAL+formulas. For the sake of brevity, it is neither specified nor used here.

270 WOLFGANG POHL

prefers an action to happen which is determined by the conclusion part of therule.

Figure 8 gives an overview of the resulting UMKB. The assumption type par-titions and stereotype partitions are shown with their most relevant contents (seeFigure 7 for details of the SB concept hierarchy). The modal formula scheme isdisplayed in the lower right.

6.5.2. Run Time

During run time, a user modeling system exchanges information about the userwith the application and dynamically constructs and maintains the user model.Since BGP-MS is anAsTRa system, it offerstell and ask interface functions,which are namedbgp-ms-tell andbgp-ms-ask, respectively. As specified in theAsTRa framework, both functions take an assumption type orAL+ expressionand a reasoning level as arguments. In our example,bgp-ms-tell was already usedduring development time for pre-defining UMKB contents. For this purpose, thereasoning level 0 was chosen, i.e., neither consistency checks nor forward reas-oning were employed. During run time,bgp-ms-tell andbgp-ms-askare invokedvia messages with the same names that can be sent to BGP-MS via inter-processcommunication.

The run time scenario is a person sitting in front of her TV set and watchingadaptive Flipper. Let us assume that both stereotypes ‘fl-adv’ and ‘action’ are ac-tivated. That is, currently the stereotype partitions SBfl-advB and SBactionPref aresuperpartitions of the assumption type partitions SBUB and SBUPref, respectively,so that their contents are also contents of the respective assumption types. Imaginea scene where an actor in a boat points to an object in the water and exclaims:

Watch out, a shark!

Afterwards, the spectator is assumed to believe that the object, which is intern-ally denoted byshark56, is a shark. To add a corresponding user model contentinto the UMKB, the message

(bgp-ms-tell (SBUB "shark(shark56)") :levelTI)

can be sent. The first argument is theAT : ac expressionSBUB:shark(shark56)(written in the Lisp notation that BGP-MS requires; FOPC assumption contentsmust appear as strings), the second argument, as indicated by the keyword:level,is the reasoning level at whichbgp-ms-tell shall operate.

SinceTI is the specified reasoning level, the consistency check and forwardinferences will be performed using type-internal reasoning, i.e., using the reasoningfunctions of the appropriate content formalism. Hence,consistentTI is called, andit invokesconsistentFOPC because FOPC is the applicable content formalism.

Sinceshark(shark56) is consistent with the current contents of SBUB (thereis no other statement involvingshark56), this content expression is stored within


assumption type SBUB. Second,forward TI and henceforwardFOPC is invoked.This not only makes use of the functionkn-otter*, which processes the FOPCcontents of SBUB, but also takes SB-ONE contents into account. In this specificcase,kn-otter* makes use of the subsumption(:isa shark dangerous), which isinherited from SBfl-advB, because the subconceptshark corresponds to the FOPCpredicate ofshark(shark56). The subsumption is handled like its logical translation

∀x shark(x)→ dangerous(x)

so thatdangerous(shark56) can be derived and entered into SBUB.Forward inference results might be used to determine subsequent utterances

of Flipper actors. Here, the possibly planned utterance ‘What a dangerous beast!’can remain unsaid, since it would convey redundant information. If the ‘fl-adv’stereotype had not been activated,SBUB:dangerous(shark56) could not have beenderived by forward inference, and the above utterance could have been made.

Now, after the user has been informed that the shark has appeared, the systemwants to know about the user’s preferences concerning the next scene. Imagine thatthere is a small set of options as to what will happen next. Then, the system cansend queries to BGP-MS concerning these options, for example

(bgp− ms− ask

(B S (Pref U (attacks flipper shark56))):level AL+).

Note the Lisp-like notation ofAL+ formulas used in BGP-MS. The:level AL+parameter option forces BGP-MS to useAL+ reasoning in answering this query.This makes perfect sense in this case, because the developer defined anAL+formula scheme that generally permits assumptions about user preferences to beinferred with the help of assumptions about user beliefs. Since theAL+ level ischosen for derivation, all other kinds of reasoning, namely type-internal reasoningand negative type reasoning, are obsolete; modal logic reasoning subsumes both.

For answering queries at theAL+ level, the functionderivableAL+ is utilized,which then makes thekn-otter function operate on an FOPC translation of thewhole UMKB. Modal formulas and schemes are translated when entered into theUMKB, typically at development time. Type-internal UMKB contents, however,are dynamically translated at run-time, using the optimized functional translationmethod mentioned in Section 6.3. In our example, the modal formula schemeallows preferences to be inferred from preference rules the conditions of whichare satisfied by user beliefs. Assumption type SBUPref inherits the preferencerule of the ‘action’ stereotype. Since the condition part of the rule matches theSBUB contentsdangerous(shark56) andhero(flipper), the modal scheme permitsBGP-MS to infer

2(B,S)2(P ref,U) attacks(flipper, shark56)

272 WOLFGANG POHL

exactly what the queried formula is. Hence, BGP-MS can answer the query with

(bgp-ms-answer :answer yes)

7. Discussion

In this section, we will compare theAsTRa framework to other systems, most ofwhich are user modeling shells, and will reflect upon the achievements and theshortcomings of our work.

7.1. USER MODELING SHELLS AND RELATED SYSTEMS

7.1.1. SHOCKER

Of all knowledge representation systems, SHOCKER (Allen & Miller, 1993), thesuccessor to the better-known RHET system (Allen & Miller, 1991; Miller, 1992),is perhaps closest to theAsTRa framework. As a system that is designed to supportnatural-language dialog systems, it is able to maintain models of other agents,while not being a genuine user modeling shell.

For knowledge representation in SHOCKER, so-called ‘belief clauses’ can beused, which may carry information about the ‘belief space’ of a clause. A simpleexample is[SB [p]], meaning that the unit clause[p] is an element of belief spaceSB15. But more complex expressions are also possible, for example

[AB [[p] < [SB [p]]]]

(the< is the backward implication arrow of SHOCKER clauses). In this example,the clause[[p] < [SB [p]]], which itself refers to belief space SB, is specifiedto be an element of belief space AB (A is an agent identifier). This exampledemonstrates that belief spaces can be related to each other, as is the case with type-external formulas in the extendedAsTRa framework. At first glance, a SHOCKERbelief clause looks like a kind of modal logic formula. However, SHOCKER intern-ally represents belief spaces with hierarchically organized partitions and automatic-ally constructs a standard hierarchy of belief spaces (like SB, MB, AB, ABMB16).In contrast toAsTRa assumption contents, belief space contents may be clausesthat refer to other belief spaces, as in the example above.

7.1.2. User Modeling Shells

The AsTra framework was developed specially for user modeling shell systemsand has been implemented in the BGP-MS shell. Other shell systems feature quitedifferent approaches. Many of them do not explicitly offer means to distinguish

15 The meaning of SB is like inAsTRa.16 The agent label A corresponds to the user label U inAsTRa. SHOCKER does not require a

leading SB in labels of belief spaces (with the exception of belief space SB itself).


between different assumption types (while their representation languagesmaybeused to do so). Moreover, other shell systems have no formal basis user modelcontents, which hence lack a clear semantics.

In GUMS (Finin, 1989), assumptions about the user are stored in one coherentknowledge base. Consequently, stereotypical assumptions about one user group arealso combined. GUMS has a single Prolog-like content formalism. In the examplesprovided by Finin, the predicate ‘knows’ is used to express SBUB assumptions,while the meaning of other expressions is less clear. With the commands ‘add’and ‘show’, GUMS offers a tell and ask interface. ‘show’ invokes a backwarddefault reasoning process and returns one of four ‘belief states’, which indicateshow strongly an assumption about the user is justified.

UMT (Brajnik & Tasso, 1994) stores all assumptions as attribute-value pairs.Similar to GUMS, user assumptions and stereotypes form distinct data sets. Inaddition to this, there are rules for forward reasoning about attribute value set-tings, and special inconsistency constraints. The epistemic character of UMKBcontents in UMT is not made explicit, and different assumption types cannot bedistinguished. However, UMT rules can be regarded as meta-rules and not as as-sumed to be believed by the user. Therefore, they correspond to view-externalexpressions (i.e.,AL+ formulas) in BGP-MS. UMT also features a tell and asknterface with a special command for giving negative feedback to UMKB answers.Moreover, UMT features an ATMS (assumption-based truth maintenance system)for handling inconsistencies in the user model.

Theum system (Kay, 1995) also uses meta-rules for forward reasoning, includ-ing stereotype inferences. The basic UMKB content entity ofum is a ‘component’,which may appear in one of three forms: minimal (a name), basic (an attribute-value pair with additional information like an evidence list), and extended (a basiccomponent which may contain information that is handled by external processes).Components can be labeled as preference, knowledge, belief, and as free attributecomponents. Thus, assumption types are distinguished component by component;the UMKB structure ofum can be described as orthogonal to that of anAsTRaimplementation. The central information in aum component is the evidence list,which is associated with the component value and mainly contains informationabout the sources of an assumption. User modeling inum basically deals with hand-ling evidence information for assumptions about the user, not with the assumptionsas such.

In the Doppelgänger system (Orwant, 1995), user models are first divided intosubmodels according to the applicability of user model contents. Within submod-els, there is a further division into assumption types like ‘biographical data’ or‘preferences’. Content representation is quite specific to these assumption types:attribute-value pairs for biographical data, simple logical assertions for prefer-ences, etc. As was the case withum, additional information such as confidencevalues and acquisition sources may be associated with assumption contents. Withinsubmodels, the UMKB structure is similar to that of theAsTRa framework, though

274 WOLFGANG POHL

the semantics of Doppelgänger assumption types is ad hoc.AsTRa content form-alisms can be used with all assumption types, but it seems plausible that someformalisms will be more suitable to a specific type than others. Likeum, Doppel-gänger also focuses on the evidence that is available for assumptions about theuser; this evidence is computed by the statistical methods that are employed foruser model acquisition.

TAGUS (Paiva and Self, 1995) was developed with learner modeling in mind. ATAGUS UMKB contains assumptions about the reasoning capabilities and strate-gies of the user/learner, both represented as rule-like structures. They can be usedto reason about user beliefs (comparable to SBUB assumptions) and non-beliefs(comparable to SB∼UB negative assumptions). Since user problem solving shallbe simulated (TAGUS is a good example of simulative inferences), some TAGUSrules reason not only about beliefs, but also about possible problem solving steps.These rules could be represented as modal formulas in the extendedAsTRa frame-work. The UMKB interface of TAGUS is quite rich, offering two ask and threetell commands, which partly make use of the truth maintenance system AMMSincluded in TAGUS.

FITS (Ikeda and Mizoguchi, 1994) is a framework for intelligent tutoring sys-tems which has been implemented as an application-independent system. Evenmore than TAGUS, FITS aims at offering generic services for student or learnermodeling. The representation and reasoning core of FITS is HSMIS, which isdescribed in detail by Kono et al. (1994). HSMIS is similar to GUMS in offering aProlog-like representation language that is extended to explicitly represent four dif-ferent truth values. In this language, assumption type information is not expressed;HSMIS only deals with student beliefs, i.e. SBUB assumptions. Reasoning in HS-MIS builds on so-called oracles, i.e., pairs of problems (questions) and studentanswers. The main activity of HSMIS then is to check whether a given oracle isconsistent with the student model and revise the model by adding or removingrules. Like UMT, HSMIS employs an ATMS for ensuring the consistency of itsstudent models over time.

The above-mentioned user modeling shells can be broadly classified into twocategories: On the one hand, there arelogic-basedshell systems like GUMS, UMT,TAGUS, and FITS. These systems provide more or less complex symbolic repres-entation formalisms. As to reasoning, they make use of forward- or backward-directed rule processing or logic-based theorem proving. Default reasoning andtruth maintenance systems are employed to deal with changes in the user model. Onthe other hand, there areevidence-basedsystems likeum and Doppelgänger. Thesesystems have simpler representation facilities, the semantics of which are more orless ad hoc. However, in contrast to logic-based shells, they represent a degree ofevidence for every assumption about the user. In addition, Doppelgänger makes adistinction between evidence (confidence, in terms of Doppelgänger) and strengthof an assumption, the latter characterizing, for example, the degree of a preferenceof the user. Thus, Doppelgänger represents SB*UPref* assumptions like Grundy


does (cf. Section 3.1.1). Evidence-based systems typically do not reason aboutuser model contents in order to arrive at additional, implicit assumptions. Theyemploy reasoning mechanisms to arrive at new information about the evidence ofassumptions. Thus, changes in the user model need not be handled by complextruth maintenance mechanisms, but are reflected by changes of evidence values.

In the above terms,AsTRa pursues a logic-based approach. However, unlikeother systems of this category, it does not provide maintenance mechanisms fordealing with user model changes. In the next subsection, we will discuss thisissue and show thatAsTRa may be regarded as a core representation and reas-oning system, which may be extended by either logic-based truth maintenance orevidence-based mechanisms.

7.2. ACHIEVEMENTS AND SHORTCOMINGS OFASTRa

TheAsTRa framework offers the following novel features from which implement-ations like BGP-MS can benefit:

– It integrates the partition approach with the modal logic approach to user modelrepresentation. Thus, the power of modal logic representation and reasoning iscombined with the flexibility and pragmatical advantages of the partition ap-proach. This integration was achieved through the introduction of the partition-like assumption type representation and reasoning approach, which can beproven equivalent to a restricted modal logic.

- It provides flexibility. The user model developer working with anAsTRa imple-mentation may choose from a variety of representation and reasoning facilities:different content formalisms within assumption types, plus modal formulasand formula schemes, and different reasoning levels. Thus, anAsTRa imple-mentation can be useful for quite a range of user modeling purposes, since –due to the bottom-up approach ofAsTRa – it is possible to employ only thosemechanisms that are most suitable to the tasks of a specific user modelingsystem. In addition, there are two further options for flexibility: First, anAsTRaimplementation may permit its clients to introduce new content formalisms.Second, the developer of anAsTRa implementation may already decide toimplement only a subset of theAsTRa mechanisms.

– Mechanisms for special treatment of negative assumptions are introduced. Sincethese mechanisms are grounded in modal logic, they were neatly integratedwith the otherAsTRa facilities.

– A full AsTRa implementation satisfies the representation needs of many usermodeling systems. It enables developers of user modeling systems to expli-citly represent assumption type information, to distinguish between differentassumption types, to use specialized formalisms for assumption contents, andto employ type-external, meta-level knowledge.

– Inference mechanisms are offered on three of fourAsTRa reasoning levels(excluding level 0) by content formalisms, specialized negative assumption

276 WOLFGANG POHL

reasoning, and modal logic reasoning. On all levels, forward- and backward-directed reasoning is possible. These options can be utilized for the acquisitionof (mainly secondary) assumptions about the user in both input- and query-driven ways. Reasoning within assumption types is of a simulative nature sinceit only concerns beliefs, goals, etc. that are ascribed to the user. Reasoningwith modal logic, however, is meta-level reasoning, since type-external modalformulas and formula schemes constitute meta-level knowledge of the system.

In the previous section, we hinted at one shortcoming of this work:AsTRaneither includes a truth maintenance method nor does it permit the representa-tion of uncertainty. Hence, it does not cope with user model dynamics, i.e., withchanging assumptions about the user. Consistency handling is restricted to the de-tection of inconsistencies between new assumptions and the current user model.However, this is not an inherent deficiency. We argue that, in principle, uncertaintymanagement and truth maintenance can be added to a system that features onlylogic-based deductive reasoning. In Section 2.2, a possible approach for combiningtype-internal expressions with evidence or uncertainty information was touched on.In general, evidence values can be associated withAsTRa UMKB contents (a) tograduate assumptions about the user or (b) to graduate the validity of meta-levelsystem knowledge that is represented as type-external expressions.

Associated evidence values might also be considered in logic-based inferenceprocesses. If the logical system infers a secondary assumption from other assump-tions, a separate mechanism may compute evidence values for the new assumptionfrom the values of the other assumptions. Thus, dependencies between graduationvalues are created, immediately related to the inferential relations of logical reas-oning. These dependencies have to be considered if graduation values are changedfrom outside. Hence, the logic-based inference process must trace its inferencesteps and record the relations between conclusions drawn and the premises used.Thus, a network is established between user model contents.

Such a network is also required for logic-based truth maintenance. The maintask of a truth maintenance system is to efficiently administer relationships betweenpremises and conclusions. So if inference traces are made available by a logic-based reasoning system, the system can be augmented with truth maintenancetechniques.

Summing up, theAsTRa framework can be regarded as a logic-based core sys-tem that is not in conflict with the nonmonotonic nature and uncertainty of usermodels. As a logic-based system, it may be extended through either uncertaintymanagement or truth maintenance. Other extensions such as mechanisms for reas-oning about time are also conceivable. Giangrandi and Tasso (1997) present such amechanism which operates in addition to, but independently of, logic-based reason-ing methods. As far as reasoning under uncertainty is concerned, less direct kindsof cooperation with logic-based systems are also possible. For instance, Jameson(1995) employs modal logic knowledge bases and the proof protocols of a modal


logic reasoner to dynamically construct parts of the Bayesian networks that areutilized for modeling dialog partners of the PRACMA system.

Besides user model dynamics, there is another crucial user modeling task thatAsTRa does not support: acquisition of primary assumptions from observations ofuser behavior. In Section 4, we have already argued that the inference engines oflogic-based knowledge representation formalisms in most cases support deductivereasoning only. Hence, they are not capable of doing primary inferences, whichis a typical inductive task. Again, we stress thatAsTRa is a core system only.Inductive learning components that typically generate implicit assessments of userpreferences, interests, etc. can cooperate with anAsTRa implementation to rep-resent the acquired assumptions explicitly, using appropriate content formalisms.SecondaryAsTRa inferences can be used to deductively augment the assumptionslearned.

From a theoretical point of view, another difficulty needs to be considered.For reasoning beyond assumption types, theAsTRa specification requires the im-plementation ofAL+ inference procedures.AL+ is a full-feature multi-modalmulti-agent logic, which allows for very complex representations that may entailtime-consuming and expensive reasoning processes. From our experiences withBGP-MS and the uses of modal logic and similar formalisms in the literature,we have observed that restricted formalisms may be sufficient in many cases. Forexample, the rules used by Ardissono and Sestero (1996) or by Appelt and Pol-lack (1992) (cf. Section 3.2) could be represented with “AL+ Horn clauses”, i.e.,combinations ofAL expressionsM(AT ) ac into rules with one conclusion ele-ment. For such a restricted formalism, more efficient inference procedures couldbe developed than for fullAL+. A general possibility for dealing with complexreasoning processes in a user modeling system is to limit reasoning resources. Thisis done in BGP-MS by limiting reasoning time of the FOPC reasoner OTTER.The rationale is that an assumption about the user which cannot be inferred withina certain amount of time is too implicit to be relevant to adaptation decisions ofapplications.

8. Conclusions

In this paper, we have presented a framework for logic-based representation andreasoning for user modeling shell systems. In principle, this framework may also beapplied in other ways, e.g. to more general agent modeling tasks. In such scenarios,more than the two ‘user modeling agents’ S and U would have to be allowed inthe formulation of assumption types and modal formulas. However, regardless ofthe application scenario, theAsTRa framework is designed to be a foundation forgeneric tools or shell systems. As such, it offers unique capabilities by integratingmodal logic with a partition-like mechanism, thus reconciling two longtime rivalapproaches. The BGP-MS user modeling shell system was presented as a pro-totypical AsTRa implementation. Inspired by experience with earlier versions of

278 WOLFGANG POHL

BGP-MS, we developed special representation and reasoning facilities for dealingwith negative assumptions; due to their modal logic foundation, they were easilybe integrated intoAsTRa.

Of course, a purely logic-based representation and reasoning system (i.e., withmerely deductive reasoning capabilities) is not sufficient for dealing with all as-pects of the user modeling task. Most obviously, and most closely related to rep-resentation and reasoning, mechanisms for dealing with user model dynamics aremissing. We have argued that such mechanisms might be developed as extensionsto AsTRa. Furthermore, the acquisition of assumptions about the user can onlypartly be supported by deductive reasoning mechanisms. For acquiring primaryassumptions, inductive machine learning techniques can be and have already beenused in user modeling systems. In future work, we plan to develop an approachto integrating inductive acquisition procedures with logic-based representation anddeductive reasoning processes into a rich user modeling architecture (Pohl, 1997a).A full-feature user modeling tool must go even further and cover such import-ant issues as privacy of user model contents and availability of user models indistributed or ubiquitous computing scenarios. Where these issues are concerned,the Doppelgänger system is a pioneer. Still, other issues remain to be resolved,e.g., the integration of adaptation features into the software engineering process.It is our hope that the application-oriented research which is currently being doneon user-adaptive systems will provide insights into such methodological researchquestions.

Acknowledgements

This paper is the result of research done largely within the BGP-MS project, whichwas funded by the German Science Foundation (DFG) under Grant No. Ko 1044/4and partially supported by the University of Konstanz under Grant No. AFF 17/92.Thanks are also due to GMD for supporting the author with a Ph.D. candidateposition. I am indebted to Alfred Kobsa for guiding and supporting my research,to Jörg Höhle for discussions and excellent implementation support, and to DetlefKüpper and Alexander Sigel for comments on earlier versions of this work.

References

Allen, J. F. and Miller, B. W.: 1991, The RHET system: A Sequence of self-guided tutorials.Technical Report 325, Computer Science Department, The University of Rochester, New York.

Allen, J. F. and Miller, B. W.: 1993, The SHOCKER System: A sequence of self-guided tutorials.Technical Report (Draft), Computer Science Department, The University of Rochester, NewYork.

Allgayer, J., Ohlbach, H. J. and Reddig, C.: 1992, Modelling agents with logic. In:Proc. of the ThirdInternational Workshop on User Modeling. Dagstuhl, Germany, pp. 22–34.

Appelt, D. E. and Pollack, M. E.: 1992, Weighted abduction for plan ascription.User Modeling andUser-Adapted Interaction2(1-2), 1–25.


Ardissono, L. and Sestero, D.: 1996, Using dynamic user models in the recognition of the plans ofthe user.User Modeling and User-Adapted Interaction5(2), 157–190.

Ballim, A.: 1992, ViewFinder: A framework for representing, ascribing and maintaining nestedbeliefs of interacting agents. Ph.D. thesis, Département d’Informatique, Université de Genève.

Ballim, A. and Wilks, Y.: 1991, Beliefs, stereotypes and dynamic agent modeling.User Modelingand User-Adapted Interaction1(1), 33–65.

Beaumont, I.: 1994, User modeling in the interactive anatomy tutoring system ANATOM-TUTOR.User Modeling and User-Adapted Interaction4(1), 21–45.

Brachman, R. J. and Schmolze, J. G.: 1985, An overview of the KL-ONE knowledge representationsystem.Cognitive Science9(2), 171–216.

Brajnik, G. and Tasso, C.: 1994, A shell for developing non-monotonic user modeling systems.International Journal of Human-Computer Studies40, 31–62.

Carberry, S.: 1989, Plan recognition and its use in understanding dialog. In: A. Kobsa and W.Wahlster (eds):User Models in Dialog Systems. Berlin, Heidelberg: Springer, pp. 133–162.

Carr, B. and Goldstein, I.: 1977, Overlays: A theory of modelling for computer-aided instruction.International Journal of Man-Machine Studies5, 215–236.

Chin, D. N.: 1986, User modelling in UC, the UNIX consultant. In:Proc. of CHI’86. pp. 24–28.Chin, D. N.: 1989, KNOME: Modeling what the user knows in UC. In: A. Kobsa and W. Wahlster

(eds.):User Models in Dialog Systems. Berlin, Heidelberg: Springer, pp. 74–107.Chin, D. N.: 1993, Acquiring user models.Artificial Intelligence Review7, 185–197.Cohen, P. R.: 1978, On knowing what to say: planning speech acts. Technical Report 118, Department

of Computer Science, University of Toronto, Canada.Cohen, R., Song, F., Spencer, B. and van Beek, P.: 1991, Exploiting temporal and novel information

from the user in plan recognition.User Modeling and User-Adapted Interaction1(2), 125–148.Finin, T. W.: 1989, GUMS: A general user modeling shell. In: A. Kobsa and W. Wahlster (eds.):User

Models in Dialog Systems. Berlin, Heidelberg: Springer, pp. 411–430.Fink, J. and Herrmann, M.: 1993, KN-PART: Ein Verwaltungssystem zur Benutzermodellierung

mit prädikatenlogischer Wissensrepräsentation. WIS-Memo 5, AG Wissensbasierte Informa-tionssysteme, Informationswissenschaft, Universität Konstanz.

Fink, J., Kobsa, A. and Nill, A.: 1996, User-oriented adaptivity and adaptability in the AVANTIproject. In:Conference ‘Designing for the Web: Empirical Studies’. Redmond, WA.

Gabbay, D. and Ohlbach, H. J.: 1992, Quantifier elimination in Second-order predicate logic. In: B.Nebel, C. Rich, and W. Swartout (eds.):Principles of Knowledge Representation and Reason-ing: Proc. of the Third International Conference (KR’92). San Mateo, CA: Morgan Kaufmann,pp. 425–435.

Giangrandi, P. and Tasso, C.: 1997, Managing temporal knowledge in student modeling. In: A.Jameson, C. Paris, and C. Tasso (eds.):User Modeling: Proceedings of the Sixth InternationalConference. Wien, New York, pp. 415–426.

Goldstein, I. P.: 1982, The genetic graph: A representation for the evolution of procedural knowledge.In: D. Sleeman and J. S. Brown (eds.):Intelligent Tutoring Systems. New York: Academic Press,pp. 51–78.

Goodman, B. A. and Litman, D. J.: 1992, On the interaction between plan recognition and intelligentinterfaces.User Modeling and User-Adapted interaction2(1-2), 55–82.

Huang, X., McCalla, G. I., Greer, J. E. and Neufeld, E.: 1991, Revising deductive knowledge andstereotypical knowledge in a student model.User Modeling and User-Adapted Interaction1(1),87–115.

Hustadt, U.: 1994, A multi-modal logic for stereotyping. In:Proceedings of the Fourth InternationalConference on User Modeling. pp. 87–92.

Hustadt, U.: 1995, Introducing epistemic operators into a description logic. In: A. Laux and H.Wansing (eds.):Knowledge and Belief in Philosophy and Artificial Intelligence, Logica Nova.Berlin: Akademie Verlag, pp. 65–86.

280 WOLFGANG POHL

Ikeda, M. and Mizoguchi, R.: 1994, FITS: A framework for ITS–A computational model of tutoring.Journal of Artificial Intelligence in Education5(3), 319–348.

Jameson, A.: 1992, Generalizing the double-stereotype approach: A psychological perspective. In:UM92 – Third International Workshop on User Modeling. pp. 69–83.

Jameson, A.: 1995, Logic is not enough: Why reasoning about another person’s beliefs is reasoningunder uncertainty. In: A. Laux and H. Wansing (eds.):Knowledge and Belief in Philosophy andArtificial Intelligence. Berlin: Akademie Verlag.

Kass, R.: 1991, Building a user model implicitly from a cooperative advisory dialog.User Modelingand User-Adapted Interaction1(3), 203–258.

Kass, R. and Finin, T.: 1988, Modeling the user in natural language systems.ComputationalLinguistics14(3), 5–22.

Kautz, H. A.: 1991, A formal theory of plan recognition and its implementation. In:Reasoning aboutPlans. San Mateo, CA: Morgan Kaufmann, pp. 69–125.

Kay, J.: 1995, Theum toolkit for reusable, long term user models.User Modeling and User-AdaptedInteraction4(3), 149–196.

Kobsa, A.: 1985,Benutzermodellierung in Dialogsystemen. Berlin, Heidelberg: Springer-Verlag.Kobsa, A.: 1989, A taxonomy of beliefs and goals for user models in dialog systems. In: A. Kobsa

and W. Wahlster (eds.):User Models in Dialog Systems. Berlin, Heidelberg: Springer, pp. 52–68.Kobsa, A.: 1990, Modeling the user’s conceptual knowledge in BGP-MS, a user modeling shell

system.Computational Intelligence6, 193–208.Kobsa, A.: 1992, Towards inferences in BGP-MS: combining modal logic and partition hierarch-

ies for user modeling. In:Proceedings of the Third International Workshop on User Modeling.Dagstuhl, Germany, pp. 35–41.

Kobsa, A., Müller, D. and Nill, A.: 1994, KN-AHS: An adaptive hypertext client of the user modelingsystem BGP-MS. In:Proc. of the Fourth International Conference on User Modeling. Hyannis,MA, pp. 99–105.

Kobsa, A. and Pohl, W.: 1995, The user modeling shell system BGP-MS.User Modeling and User-Adapted Interaction4(2), 59–106.

Kono, Y., Ikeda, M. and Mizoguchi, R.: 1994, THEMIS: A nonmonotonic inductive student modelingsystem.Journal of Artificial Intelligence in Education5(3), 371–413.

Kripke, S.: 1963, Semantic considerations on modal logic.Acta Philosophica Fennica16, 83–94.McCauley, C., Stitt, C. L. and Segal, M.: 1980, Stereotyping: From prejudice to prediction.

Psychological Bulletin87, 195–208.McCune, W. W.: 1994, OTTER 3. Reference manual and guide. Technical Report ANL-94/6,

Argonne National Laboratory, Mathematics and Computer Science Division, Argonne, IL.McTear, M. F.: 1993, User modelling for adaptive computer systems: a survey.Artificial Intelligence

Review7(3-4), 157–184.Miller, B. W.: 1992, The rhetorical knowledge representation system reference manual. Technical

Report 326 (revised), Computer Science Department, The University of Rochester, New York.Minsky, M.: 1975, A framework for representing knowledge. In: P. Winston (ed.):The Psychology

of Computer Vision. New York: McGraw-Hill.Moore, J. D. and Paris, C. L.: 1992, Exploiting user feedback to compensate for the unreliability of

user models.User Modeling and User-Adapted Interaction2(4), 331–365.Morik, K.: 1989, User models and conversational settings: modeling the user’s wants’. In: A. Kobsa

and W. Wahlster (eds.):User Models in Dialog Systems. Berlin, Heidelberg: Springer-Verlag,pp. 364–385.

Niem, L., Fugère, B. J., Rondeau, P. and Tremblay, R.: 1993, Defining the semantics of extendedgenetic graphs.User Modeling and User-Adapted Interaction3(2), 107–153.

Nwana, H. S.: 1991, User modelling and user adapted interaction in an intelligent tutoring system.User Modeling and User-Adapted Interaction1(1), 1–32.


Ohlbach, H. J.: 1991, Semantics-based translation methods for modal logics.Journal of Logic andComputation1(5), 691–746.

Orwant, J.: 1995, Heterogeneous learning in the doppelgänger user modeling system.User Modelingand User-Adapted Interaction4(2), 107–130.

Paiva, A. and Self, J.: 1995, TAGUS – A user and learner modeling workbench.User Modeling andUser-Adapted Interaction4(3), 197–226.

Paris, C.: 1989, The use of explicit user models in a generation system for tailoring answers to theuser’s level of expertise. In: A. Kobsa and W. Wahlster (eds.):User Models in Dialog Systems.Berlin, Heidelberg: Springer, pp. 133–162.

Peter, G. and Rösner, D.: 1994, User-model-driven generation of instructions.User Modeling andUser-Adapted Interaction3(4), 289–319.

Pohl, W.: 1996, Combining partitions and modal logic for user modeling. In: D. M. Gabbay and H.J. Ohlbach (eds.):Practical Reasoning: Proceedings of the International Conference on Formaland Applied Practical Reasoning. Berlin, Heidelberg, pp. 480–494.

Pohl, W.: 1997a, LaboUr – machine learning for user modeling. In: M. J. Smith, G. Salvendy,and R. J. Koubek (eds.):Design of Computing Systems: Social and Ergonomic Considerations(Proceedings of the Seventh International Conference on Human-Computer Interaction), Vol. B.Amsterdam, pp. 27–30.

Pohl, W.: 1997b, Logic-based representation and reasoning for user modeling shell systems. Ph.D.thesis, University of Essen.

Pohl, W. and Höhle, J.: 1997, Mechanisms for flexible representation and use of knowledge inuser modeling shell systems. In: A. Jameson, C. Paris, and C. Tasso (eds.):User Modeling:Proceedings of the Sixth International Conference. Wien, New York, pp. 403–414.

Pohl, W., Höhle, J., Fink, J. and Kim, D. W.: 1995a, Building adaptive applications on widely-used platforms with BGP-MS. In: C. Stephanidis (ed.):Proc. ERCIM Workshop “Towards UserInterfaces for All: Current Efforts and Future Trends”. Heraklion, Greece.

Pohl, W., Kobsa, A. and Kutter, O.: 1995b, User model acquisition heuristics based on dialogueacts. In:International Workshop on the Design of Cooperative Systems. Antibes-Juan-les-Pins,France, pp. 471–486.

Quilici, A.: 1989, AQUA: A system that detects and responds to user misconceptions. In: A. Kobsaand W. Wahlster (eds.):User Models in Dialog Systems. Berlin, Heidelberg: Springer.

Quilici, A.: 1994, Forming user models by understanding user feedback.User Modeling and User-Adapted Interaction3(4), 321–358.

Quillian, M.: 1968, Semantic memory. In: M. Minsky (ed.):Semantic Information Processing.Cambridge, MA: MIT Press, pp. 216–270.

Retz-Schmidt, G.: 1991, Recognizing intentions, interactions, and causes of plan failures.UserModeling and User-Adapted Interaction1(2), 173–202.

Rich, E.: 1979, User modeling via stereotypes.Cognitive Science3, 329–354.Rich, E.: 1983, Users are individuals: Individualizing user models.Journal of Man-Machine Studies

18, 199–214.Rich, E.: 1989, Stereotypes and user modeling. In: A. Kobsa and W. Wahlster (eds.):User Models in

Dialog Systems. Berlin, Heidelberg: Springer, pp. 35–51.Russell, S. and Norvig, P.: 1995,Artificial Intelligence: A Modern Approach. Upper Saddle River,

NJ: Prentice-Hall.Sarner, M. and Carberry, S.: 1992, Generating tailored definitions using a multifaceted user model.

User Modeling and User-Adapted Interaction2(3), 181–210.Schauer, H. and Pohl, W.: 1997, Generating secondary assumptions in BGP-MS. In: R. Schäfer and

M. Bauer (eds.):ABIS-97: 5. GI-Workshop Adaptivität und Benutzermodellierung in interaktivenSoftwaresystemen.SFB 378, Memo 65. Saarbrücken.

Scherer, J.: 1990, SB-PART: Ein Partitionsverwaltungssystem für die WissensrepräsentationsspracheSB-ONE. Memo 48, Projekt XTRA, Fachbereich Informatik, Universität Saarbrücken.

282 WOLFGANG POHL

Shifroni, E. and Shanon, B.: 1992, Interactive user modeling: An integrative explicit-implicitapproach.User Modeling and User-Adapted Interaction2(4), 287–330.

Sleeman, D.: 1985, UMFE: A user modelling front-end subsystem.International Journal of Man-Machine Studies23, 71–88.

Tattersall, C.: 1992, Generating help for users of application software.User Modeling and User-Adapted Interaction2(3), 211–248.

Taylor, J. A., Carletta, J. and Mellish, C.: 1996, Requirements for belief models in cooperativedialogue.User Modeling and User-Adapted Interaction6(1), 23–68.

Wahlster, W. and Kobsa, A.: 1989, User models in dialog systems. In: A. Kobsa and W. Wahlster(eds.):User Models in Dialog Systems. Berlin, Heidelberg: Springer, pp. 4–34.

Weida, R. and D. Litman: 1992, Terminological reasoning with constraint networks and an applica-tion to plan recognition. In: B. Nebel, C. Rich, and W. Swartout (eds.):Principles of KnowledgeRepresentation and Reasoning: Proc. of the Third International Conference (KR’92). San Mateo,CA: Kaufmann, pp. 282–293.

Wu, D.: 1991, Active acquisition of user models: Implications for decision-theoretic dialog planningand plan recognition.User Modeling and User-Adapted Interaction1(2), 149–172.

Zimmermann, J.: 1994, Hybride Wissensrepräsentation in BGP-MS: Integration der Wissensver-arbeitung von SB-ONE und OTTER. WIS-Memo 12, AG Wissensbasierte Informationssysteme,Informationswissenschaft, Universität Konstanz.

Zukerman, I. and McConachy, R.: 1993, Consulting a user model to address a user’s inferencesduring content planning.User Modeling and User-Adapted Interaction3(2), 155–185.

Author’s Vita

W. PohlGMD National Research Center for Information Technology, Institute for Ap-plied Information Technology (FIT), Human-Computer Interaction Research De-partment (MMK), Schloss Birlinghoven, D-53754 St. Augustin, Germany; e-mail:[email protected]

Wolfgang Pohl received his diploma (master’s degree, 1992) in Computer Sci-ence from the University of Bonn, and his Ph.D. (1997) in Computer Science fromthe University of Essen. From 1992 to 1997, he held full research positions atthe Universities of Konstanz and Essen, where he developed representation andreasoning facilities for the BGP-MS user modeling shell system. In 1997 he joinedGMD FIT and currently works as senior researcher and project manager of theLaboUr (Learning about the User) project on the integration of machine learningmethods into a complete user modeling architecture. This paper is based on hisdissertation research.

Documents

Logic-Based Representation and Reasoning for User Modeling Shell Systems