JTP
Download
1 / 23

JTP A Query Answering System For Knowledge Represented in DAML - PowerPoint PPT Presentation


  • 50 Views
  • Uploaded on

JTP A Query Answering System For Knowledge Represented in DAML. Richard Fikes Gleb Frank Jessica Jenkins. Knowledge Systems Laboratory Stanford University www.ksl.stanford.edu. 7/12/02. Hybrid Reasoning for Answering Queries. JTP has a hybrid reasoning architecture

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' JTP A Query Answering System For Knowledge Represented in DAML' - garth-daniels


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

JTP

A Query Answering System

For Knowledge

Represented in DAML

Richard Fikes

Gleb Frank Jessica Jenkins

Knowledge Systems Laboratory

Stanford University

www.ksl.stanford.edu

7/12/02


Hybrid reasoning for answering queries
Hybrid Reasoning for Answering Queries

  • JTP has a hybrid reasoning architecture

    • First-order logic model elimination theorem prover

    • Suite of special purpose reasoners

    • Dispatchers and APIs for reasoners

  • Infers query answers that are logical constants

    • Explicitly mentioned in the KB, or

    • Defined in DAML+OIL

  • Implemented in JAVA

  • Available from the Web

    • Used by SAIC in ARDA’s AQUAINT program

    • Used by UWF and NAI in DARPA’s UltraLog program

    • To be used by BBN in DARPA’s DAML program


Jtp s daml oil reasoner
JTP’s DAML+OIL Reasoner

  • Precomputes most query answers as KB is loaded

    • Enables rapid replies to queries

  • Based on the axiomatic semantics for DAML+OIL

  • Compiles axioms into forward chaining actions

    E.g., the following axiom:

    (=> (and (oneOf ?c ?l) (item ?l ?x))

    (type ?x ?c))

    compiles into an action that

    • Fires whenever a class C is asserted to be “oneOf” a list L.

    • Activates an action that

      • Fires when an object X is asserted to be an “item” of L.

      • Asserts that X is type C.

  • Efficiently stores DAML+OIL sentences (triples)

    E.g., linking of values of transitive properties such as subClassOf


  • Recent developments
    Recent Developments

    • Usability improvements for KB testing and debugging

      • Support for rapid reloading and changing of developing KBs

        • Load multiple KB modules with checkpointing after each load

        • “untell” command using “undo”, “redo”, and checkpoints

      • Significant reduction in time required to load KBs

    • Hierarchical display of reasoning explanations

      • Includes template-based “natural language” descriptions

        E.g., “(usedEncryptionAlgorithm C-001 A)” displayed as

        “Algorithm A is used to encrypt communication C-001”

    • Added classifier to DAML+OIL reasoner

    • Developing reasoners for time-dependent answers

      • Based on a reusable time ontology developed at KSL

    • Expanding inferences made by DAML+OIL reasoner 


    Negation using complements
    Negation Using Complements

    • DAML+OIL does not include explicit negation

      I.e., cannot say “(not …)” in DAML+OIL

    • Negation is related to complements via these axioms:

      • “If NC is the complement of C, then X is not type C exactly when X is type NC.”

        (=> (complementOf ?c ?nc)

        (<=> (not (type ?x ?c)) (type ?x ?nc)))

      • “If R is the class of all objects that have Y as a value of property P and NR is the complement of R, then Y is not a value of P for X exactly when X is type NR.”

        (=> (and (onProperty ?r ?p)

        (hasValue ?r ?y)

        (complementOf ?r ?nr))

        (<=> (not (holds ?p ?x ?y)) (type ?x ?nr)))


    Inferring negations using complements
    Inferring Negations Using Complements

    • Consider the defining axiom for toClass restrictions

      “If R is the class of objects all of whose values of P are type C, X is type R, and V is a value of P for X, then V is type C.”

      (=> (and (onProperty ?r ?p) (toClass ?r ?c)

      (type ?x ?r) (holds ?p ?x ?v))

      (type ?v ?c))

    • That axiom is equivalent to the following:

      “If R is the class of objects all of whose values of P are type C, X is type R, and V is not type C, then V is not a value of P for X.”

      (=> (and (onProperty ?r ?p) (toClass ?r ?c)

      (type ?x ?r) (not (type ?v ?c)))

      (not (holds ?p ?x ?v)))


    Inferring negations using complements1
    Inferring Negations Using Complements

    • The axiom:

      “If R is the class of objects all of whose values of P are type C, X is type R, and V is not type C, then V is not a value of P for X.”

      (=> (and (onProperty ?r ?p) (toClass ?r ?c)

      (type ?x ?r) (not (type ?v ?c)))

      (not (holds ?p ?x ?v)))

      is equivalent to:

      “If R is the class of objects all of whose values of P are type C, X is type R, CC is the complement of C, V is type CC, R2 is the class of objects that have V as a value of P, and CR2 is the complement of R2, then X is type CR2.”

      (=> (and (onProperty ?r ?p) (toClass ?r ?c)

      (type ?x ?r)

      (complementOf ?c ?cc) (type ?v ?cc)

      (onProperty ?r2 ?p) (hasValue ?r2 ?v)

      (complementOf ?r2 ?cr2))

      (type ?x ?cr2)))

      which can be used as a forward chaining rule. (!)


    Compiling actions for complements
    Compiling Actions For Complements

    • JTP compiles implicative normal form sentences into forward chaining actions

      (=> (and L1 … Ln) Lx)

      is compiled into an action that fires when an Li is asserted

    • Rule compiler will be expanded as follows:

      • Produce redundant forms of each input

        (=> (and L1 … Li-1 Li+1 … Ln (not Lx))

        (not Li))

      • Replace negations by complements

        (=> (and L1 … Li-1 Li+1 … Ln

        … (complement …) (type …) … (complement …))

        (type …))

      • Produce forward chaining actions from the redundant forms

        • Essentially adds actions that fire when (not Lx) is asserted


    Subclass hierarchy inferred by jtp
    Subclass Hierarchy Inferred By JTP

    (Union C1 … Cn) = ~(Intersect ~C1 … ~Cn)

    (Union (Subset C1 … Cn))

    Ci

    (Intersect (Subset C1 … Cn))

    (Intersect C1 … Cn) = ~(Union ~C1 … ~Cn)


    Recognizing individuals
    Recognizing Individuals

    • JTP uses forward chaining to recognize individuals

    • Example identifying forward chaining actions:

      • “If X is type CSUB and CSUB is a subclass of CSUPER, then X is type CSUPER.”

        (=> (and (subClassOf ?csub ?csuper) (type ?x ?csub))

        (type ?x ?csuper))

      • “If the range of property P is R and Y is a value of P for some X, then Y is type R.”

        (=> (and (range ?p ?r) (holds ?p ?x ?y)) (type ?y ?r))

      • “If the domain of property P is D and X has a value for P, then X is type D.”

        (=> (and (domain ?p ?d) (holds ?p ?x ?y)) (type ?x ?d))

      • “If X is equivalent to Y and X is type C, then Y is type C.”

        (=> (and (equivalentTo ?x ?y) (type ?x ?c)) (type ?y ?c))


    Forward chaining recognition actions
    Forward Chaining Recognition Actions

    • “If X is an instance of every item on L and C is the intersection of the items on L, then X is an instance of C.”

      (=> (and (intersectionOf ?c ?l)

      (forall ?i (=> (item ?l ?i) (type ?x ?i))))

      (type ?x ?c))

    • “If class C is oneOf list L and X is an item of L, then X is type C.”

      (=> (and (oneOf ?c ?l) (item ?l ?x)) (type ?x ?c))

    • “If R is the class of all objects for which all values of property P are type C, X is type R, and V is a value of P for X, then V is type C.”

      (=> (and (onProperty ?r ?p) (toClass ?r ?c)

      (type ?x ?r) (holds ?p ?x ?v))

      (type ?v ?c))


    Recognizing individuals in complements
    Recognizing Individuals In Complements

    • New compiler will produce recognition actions (!)

    • Examples

      • “If R is the class of objects all of whose values of P are type C, X is type R, and V is a value of P for X, then V is type C.”

        (=> (and (onProperty ?r ?p) (toClass ?r ?c)

        (type ?x ?r) (holds ?p ?x ?v))

        (type ?v ?c))

        From that axiom the compiler produces:

        “If R is the class of objects all of whose values of P are type C, X is type R, CC is the complement of C, V is type CC, R2 is the class of objects that have V as a value of P, and CR2 is the complement of R2, then X is type CR2.”

        (=> (and (onProperty ?r ?p) (toClass ?r ?c) (type ?x ?r)

        (complementOf ?c ?cc) (type ?v ?cc)

        (onProperty ?r2 ?p) (hasValue ?r2 ?v)

        (complementOf ?r2 ?cr2))

        (type ?x ?cr2)))


    Recognizing individuals in complements1
    Recognizing Individuals In Complements

    • Examples of recognition actions the new compiler will produce

      • “If Csub is a subclass of Csuper and X is type Csub, then X is type Csuper.”

        (=> (and (subClassOf ?csub ?csuper) (type ?x ?csub))

        (type ?x ?csuper))

        From that axiom the compiler produces:

        “If Csub is a subclass of Csuper, C-Csub is the complement of Csub, C-Csuper is the complement of Csuper, and X is type C-Csuper, then X is type C-Csub.”

        (=> (and (subClassOf ?csub ?csuper)

        (complementOf ?ccsub ?csub)

        (complementOf ?ccsuper ?csuper)

        (type ?x ?ccsuper))

        (type ?x ?ccsub)))


    Cryptographic policy example
    Cryptographic Policy Example

    • In this DAML ontology, CommunicationActionBetweenAG1AndAG2 is the class of all actions in which the action is performedBy AG1 and hasDestination AG2.

      • http://ksl.stanford.edu/DAML/ultralog/CryptographicPolicies1.daml

    • There is a restriction on the class that all communications between these two groups must be encrypted with encryption scheme A.


    A specific communication instance
    A Specific Communication Instance

    • Communication-001 is an instance of a communication between group AG1 and group AG2.

    • Note:

      • Communication-001 is not asserted to be an instance of CommunicationActionBetweenAG1AndAG2

      • Communication-001 is not asserted to be encrypted.


    Here we ask jtp what algorithm communication 001 was encrypted with
    Here, we ask JTP what algorithm Communication-001 was encrypted with:

    And the answer is….

    A (!)


    Proof browser
    Proof Browser encrypted with:

    The proof, displayed in the Proof Browser, explains how JTP figured out that the encryption algorithm used was A.

    In the left pane is the entire proof tree. In the right pane is a detailed view of the selected proof.


    Here, we see that Communication-001 has the value “A” for the property usedEncryptionAlgorithm because Communication-001 is an instance of the anonymous restriction Anon_7, and Anon_7 specifies that all of its instances must have “A” as a value of usedEncryptionAlgorithm.


    Communication-001 is an instance of Anon_7 because it is an instance of CommunicationActionBetweenAG1AndAG2, and CommunicationActionBetweenAG1AndAG2 is a subclass of Anon_7.

    But why is Communication-001 an instance of CommunicationActionBetweenAG1AndAG2?


    Communication-001 is an instance of both Anon_5 and Anon_6. There is a rule which states that if a resource is an instance of both Anon_5 and Anon_6, then it must be an instance of CommunicationActionBetweenAG1AndAG2.

    This rule was created by a special-purpose forward-chaining action. It was created because CommunicationActionBetweenAG1AndAG2 is defined to be the intersectionOf the list Anon_8, and Anon_5 and Anon_6 are the items in Anon_8.


    Communication-001 is an instance of the restriction Anon_6 because it has a value AG1 for the property performedBy.


    Similarly, Communication-001 is an instance of Anon_5 because it has a value AG2 for the property hasDestination.


    Jtp summary
    JTP Summary because it has a value AG2 for the property hasDestination.

    • Hybrid reasoning system for query answering

    • Special purpose reasoner for DAML+OIL

    • Easily extendable by adding special purpose reasoners

    • Current and recent developments

      • Usability improvements for KB testing and debugging

      • Hierarchical display of reasoning explanations

        • Includes template-based “natural language” descriptions

      • Added classifier to DAML+OIL reasoner

      • Developing reasoners for time-dependent answers

        • Based on a reusable time ontology developed at KSL

      • Expanding inferences made by DAML+OIL reasoner

        • Reasoning with complements

        • Recognizing individuals


    ad