QN ASKING


How the SME will State Questions
--------------------------------
In the first version of Shaken, we will adopt a template-based method
for posing questions to the system, similar to that used in the HPKB
project. In this approach, the SME poses a question by first selecting
from a small set of general question types, and then "filling in the blanks"
for the various parameters which are required to instantiate the question.
For example, one such question type is "What are the parts of <structured
object?", which might be instantiated as "What are the parts of a cell?".

We recognize that this approach does not account for many of the questions
which the SME may want to ask, and consider it merely a starting point for the
first version of the system. This is appropriate, as answering more complex 
questions require at least the ability to answer these "template" questions,
thus allowing us incremental development. In addition, we hope a large number 
of SME questions will conform to the template-based approach.

Templates can be presented and filled in in various ways. In the initial
version of the system, and as illustrated in the story-board [if you 
include my slides Vinay], the SME first selects the main concept he/she
wants to ask a question about. Shaken will then provide a list of
question templates which are applicable to this type of concept, filtering
out those which don't apply (e.g. "What happens during <X>?" only
applies to processes, not physical objects). The SME will then click on
the question he/she wants to ask. Some questions may include pull-down
menus for additional parameters required in the question.

How Questions will be Answered
------------------------------
Each question template is twinned with an "Explanation Design Plan" (EDP),
specifying what information is required in the answer (i.e. what constitutes
an adequate answer to the SME's question). The EDP takes as 
input the object(s) which the user supplied when posing the question.
Questions will be answered through a four-step process:
 1. Creation: Create a representation of the object/scenario the SME is 
	asking about. For example, if the SME is asking about a Virus,
	then create an instance of a Virus in the KB to reason about.
	In more complex cases, the system may query the SME to provide
	additional details about this scenario.
 2. Elaboration: Using rules in the KB, infer additional information about
	the scenario which is needed for the answer. This step is guided
	by the EDP for the question-type, specifying what information
	should be included in the answer - in other words, the EDP specifies
	a number of questions to pose to the scenario, possibly triggering
	inference, and collects the answers to those questions.
 3. Assembly: Gather the inferred information together into a nicely formatted
	result.
 4. Presentation: Present it to the user.

In the simplest case, the answer to a question will simply be the value(s)
on an object's slot. In more complex cases (e.g. "What is a <object>?")
a number of pieces of information are required (e.g. generalizations, 
distinguishing features, parts, purpose). The EDP specifies what those
are, and the order to present them. A tentative list of EDPs are given
in Appendix ? of this document.

As part of the question-answering procedure, 
the system will need to convert from
raw KB object names (e.g. _Virus01, _Membrane02) to English phrases/sentences
(e.g. "a virus", "a membrane") for presentation to the user. This will
be done using simple "fill in the blank" text templates attached to 
KB objects, already supported in the inference engine KM. Although lacking the
sophistication of complex language generation tools, this simple approach
has proved largely adequate in earlier systems.

-- end --

======================================================================
	APPENDIX
======================================================================

An initial list of question templates to be used in Shaken. This list
will probably change and extend as the system develops.

Question type: What are the parts of <structured object>?
Example: "What are the parts of a cell?"
Representational Requirements Include: Partonomy for <structured object>
Description Generation Requires: Computation and display of slot-values.

Question type: Where is <object> located in a <object>?
Example: "Where is the DNA located in a cell?"
Representational Requirements include: 
	Partonomy plus representation of relative spatial locations.
Description Generation Requires: Computation and display of slot-values.

Question type: What is the <value> of <attribute>?
Example: "What is the atomic weight of carbon?"
Representational Requirements include: Simple database tables of information.
Description Generation Requires: Simple look-up in these tables.

Question type: Describe <process>. also; How do I do <process>?
Example: "Describe how a virus invades a cell."
Representational Requirements include: Generalizations, representation of
the actors and roles they play, a hierarchical, script-like representation of 
event sequences.
Description Generation Requires: Construction of a structured answer, 
presenting the generalizations; actors and roles; sequential description
of each step in turn; hyperlinks where further information is available.

Question type: What role does <object> play in <process>?
Example: "What role does the membrane play when a virus invades a cell?
Representational Requirements include: process descriptions.
Description Generation Requires:
	Tools for analyzing the process description, and possibly
	running a simulation of the process.

Question type: What is the effect of <change> <parameter> on/when/during <process>?
Example: "What is the effect of increasing acidity when a virus invades a cell?
Representational Requirements include:  process descriptions.
Description Generation Requires:
	Simulation of the process with changed initial conditions, and
	analyzing the result.

Question type: Under what conditions does <event> occur?
Example: "Under what conditions does endoctosis occur?"
Representational Requirements include:
  Representation of possible scenarios.
Description Generation Requires:
  Ability to scan scenarios for an event's occurrence. 

Question type: What is the purpose of <object>?
Example: "What is the purpose of differential carrier proteins?"
Representational Requirements include: Representation of activities, and the
        role different objects play in those activities. Additional annotation
        of which of these are intended roles (purpose) of objects.
Description Generation Requires: Analysis of these activities.

Question type: How is <constraint> achieved/prevented [during <process>]?
Example: "How is hydrophobic contact prevented during membrane transport?"
Representational Requirements include:
  Representation of the purpose of objects in an an assembly.
Description Generation Requires: Identification of the relevant 
	process achieving/preventing the constraint; use of the
	same process description generation method as mentioned earlier.

Question type: What is <object>?
Example: "What is a carrier protein?"
Representational Requirements include: No new Representational Requirements, rather 
	an integration answers to various other questions.
Description Generation Requires: Answering these other questions and
assembling the answers into a single paragraph. These other questions
will query for: the object's generalizations,  distinguishing features/restrictions,
its parts, its purpose, and activities it participates in.

Question type: "What types of <object> are there?" 
Example: "What types of protein are there?"
Representational Requirements include:
  A particular model/ontology for an object type.
Description Generation Requires: Retrieval and presentation of subtrees of
  the knowledge-base's isa hierarchy.