Thesis by ewghwehws

VIEWS: 2 PAGES: 37

									               Updating
               Description Logic
               Knowledge Bases
A Dissertation to the Degree of Master Science in Computer Science

               Submitted by: Dmitriy Zheleznyakov
               Faculty Advisor: prof. Diego Calvanese
               KRDB Research Centre
Outline
1.   Ontologies and Description Logics
2.   Problem Definition
3.   Contributions of the Work
4.   Instance-Level Update: Details
5.   Intensional-Level Update: Details
6.   Conclusion

                                         2/28
Ontology

           Intensional-level:
           specifies a set of conceptual elements
           and of rules to describe the
           conceptual structures of the domain.



           Instance-level:
           specifies a set of instances of the
           conceptual elements
           described at the intensional level.




                                                 3/28
Ontology
   Ontology formally represents a domain of
    interest
   Ontologies are used in many areas:
         Semantic Web
         Artificial Intelligence
         Software Engineering
         …


                                               4/28
Ontologies: Description Logics
   Description Logics (DLs) provide a solid
    foundation for:
          Ontology representation
          Reasoning over them

   Key components of DLs:
          Concepts
          Roles


                                               5/28
Ontology: Description Logics
   A DL knowledge base (KB) K consists of:
          TBox T: represents the intensional-level, the
           general knowledge
          Abox A: provides information on the instance-
           level

   Formal semantics of DLs based on FOL:
          Model ∼ State of the World
          In general, a DL KB has many models


                                                           6/28
  Intensional-Level: Vocabulary
              Employee
          empCode: Integer    1..*
          salary: Integer


                                     worksFor
 boss                                   ▼
  ▼
               Manager                      Project
                                       projectName: String




                                                  1..1
        {disjoint}
                                     manages
                                       ▲

AreaManager                  TopManager
                                                  1..1



                                                             7/28
  Intensional-Level: Vocabulary
              Employee                                       Concepts:   Employee, Manager,
          empCode: Integer    1..*                                       Project, AreaManager,
          salary: Integer
                                                                                   TopManager
                                     worksFor
 boss                                   ▼
  ▼
                                                             Roles:      boss, worksFor,
                                                                         manages
               Manager                      Project
                                       projectName: String




                                                  1..1
        {disjoint}
                                     manages
                                       ▲

AreaManager                  TopManager
                                                  1..1



                                                                                                 7/28
  Intensional-Level: Vocabulary
              Employee                                       Concepts:     Employee, Manager,
          empCode: Integer    1..*                                         Project, AreaManager,
          salary: Integer
                                                                                     TopManager
                                     worksFor
 boss                                   ▼
  ▼
                                                             Roles:        boss, worksFor,
                                                                           manages
               Manager                      Project
                                       projectName: String
                                                             Attributes:   empCode, salary,
                                                                           projectName
                                                  1..1
        {disjoint}
                                     manages
                                       ▲

AreaManager                  TopManager
                                                  1..1



                                                                                                   7/28
  Intensional-Level: TBox
                                                             TBox T:
              Employee                                       Manager ⊑ Employee
          empCode: Integer    1..*
          salary: Integer                                    AreaManager ⊑ Manager
                                     worksFor
                                                             TopManager ⊑ Manager
 boss                                   ▼                    TopManager ⊑ ¬AreaManager
  ▼
                                                             ∃manages ⊑ TopManager
               Manager                      Project          ∃manages– ⊑ Project
                                       projectName: String   …

                                                  1..1
                                                             δ(empCode) ⊑ Employee
        {disjoint}                                           ρ(empCode) ⊑ Integer
                                     manages                 …
                                       ▲
                                                             (funct manages)
AreaManager                  TopManager
                                                  1..1
                                                             TopManager ⊑ ∃project


                                                                                         7/28
  Instance-Level: ABox
                                                             ABox A:
              Employee                                       Employee(john)
          empCode: Integer    1..*
          salary: Integer
                                                             TopManager(frank)
                                     worksFor
 boss                                   ▼
                                                             AreaManager(john)
  ▼
               Manager                      Project          manages(lisa, pr2)
                                       projectName: String




                                                  1..1
        {disjoint}
                                     manages
                                       ▲

AreaManager                  TopManager
                                                  1..1



                                                                                  8/28
  Instance-Level: Reasoning
                                                             ABox A:
              Employee                                       Employee(john)
          empCode: Integer    1..*
          salary: Integer
                                                             TopManager(frank)
                                     worksFor
 boss                                   ▼
                                                             AreaManager(john)
  ▼
               Manager                      Project          manages(lisa, pr2)
                                       projectName: String
                                                             Reasoning:
                                                             T, A ⊨ TopManager(lisa)
                                                  1..1       T, A ⊨ Manager(lisa)
        {disjoint}
                                     manages                 T, A ⊨ Employee(lisa)
                                       ▲

AreaManager                  TopManager
                                                  1..1



                                                                                       8/28
Outline
   Ontologies and Description Logics
   Problem Definition
   Contributions of the Work
   Instance-Level Update: Details
   Intensional-Level Update: Details
   Conclusion

                                        9/28
Ontology Evolution
   In the last 20 years, research has concen-
    trated on static aspects of ontologies
   Ontologies may evolve in time
   Recently, there is a lot of interest in
    ontology evolution, but only few results



                                                 10/28
Evolution by Means of Update
        Ontology O            Ontology O'

                                                   ?

     Set of models S                        Set of models S'

                       Update F




                                                          11/28
Outline
1.   Ontologies and Description Logics
2.   Problem Definition
3.   Contributions of the Work
4.   Instance-Level Update: Details
5.   Intensional-Level Update: Details
6.   Conclusion

                                         12/28
Contributions
   We considered two types of update:
          Instance-level update
          Intensional-level update

   Our main contributions are:
          Polynomial time algorithm for instance-level
           update for DL-LiteA
          Polynomial time algorithm for intensional-level
           update for DL-LiteFR


                                                             13/28
Outline
1.   Ontologies and Description Logics
2.   Problem Definition
3.   Contributions of the Work
4.   Instance-level Update: Details
5.   Intensional-level Update: Details
6.   Conclusion

                                         14/28
Update: Model-based Approach




            Set of models S                           Set of models S'
 Each model M satisfies:                   Each model M' satisfies:
              TBox T                                     TBox T
                         Update F
              ABox A                                     update F
                                                         ABox A'
 We want to compute A' such that the difference between
 each M and the corresponding M' is as small as possible         15/28
Instance-level Update
   The notion of instance-level update has
    been studied for simple DLs (DL-LiteF)
   In this work we extend existing results to
    DL-LiteA, which is a more expressive
    language
             DL-LiteA ⊂ DL-LiteF

                                                 16/28
  Instance-level Update
                                                             ∃manages ⊑ TopManager
              Employee
          empCode: Integer    1..*                           TopManager ⊑ ¬AreaManager
          salary: Integer
                                                             (funct manages–)
                                     worksFor
 boss                                   ▼                    AreaManager(john)
  ▼                                                          manages(lisa, pr2)
               Manager                      Project
                                       projectName: String   F= {manages(john, pr2)}

                                                  1..1       T, A' ⊨ TopManager(john)
        {disjoint}
                                     manages                 T, A' ⊭ AreaManager(john)
                                       ▲                     T, A' ⊭ manages(lisa, pr2)
AreaManager                  TopManager
                                                  1..1



                                                                                          17/28
  Instance-level Update
                                                             ∃manages ⊑ TopManager
              Employee
          empCode: Integer    1..*                           TopManager ⊑ ¬AreaManager
          salary: Integer
                                                             (funct manages–)
                                     worksFor
 boss                                   ▼                    manages(john, pr2)
                                                             AreaManager(john)
  ▼                                                          manages(lisa, pr2)
               Manager                      Project
                                       projectName: String   F= {manages(john, pr2)}

                                                  1..1          A ⊨ TopManager(john)
                                                             T, A' ⊨ TopManager(lisa)
        {disjoint}
                                     manages                    A ⊭ AreaManager(john)
                                                             T, A' ⊨ Manager(lisa)
                                       ▲                        A ⊭ manages(lisa,
                                                             T, A' ⊨ Employee(lisa) pr2)
AreaManager                  TopManager
                                                  1..1



                                                                                           17/28
  ABox Update Algorithm
                                                             ∃manages ⊑ TopManager
              Employee
          empCode: Integer    1..*                           TopManager ⊑ ¬AreaManager
          salary: Integer
                                                             (funct manages–)
                                     worksFor
 boss                                   ▼                    TopManager(lisa)
                                                             AreaManager(john)
  ▼                                                          manages(lisa, pr2)
                                                             manages(john, pr2)
               Manager                      Project
                                       projectName: String   F= {manages(john, pr2)}


                                                             T, A' ⊨ TopManager(lisa)
                                                  1..1

                                                             T, A' ⊨ Manager(lisa)
        {disjoint}
                                     manages
                                       ▲
                                                             T, A' ⊨ Employee(lisa)
AreaManager                  TopManager
                                                  1..1



                                                                                         18/28
Basic Steps of Update
 Checking co-satisfiability of TBox T and of
  update F, then closing F
 Building minimal set of assertions, contra-
  dicting F and implied by O, and their
  implications
   Deleting contradictory part, inserting
    implications and F

                                                19/28
ABox Update Algorithm
 The size of A' is polynomially bounded
  by the size of T ∪ A ∪ F
 Computing A' can be done in polynomial
  time in the size of T ∪ A ∪ F




                                           20/28
Outline
1.   Ontologies and Description Logics
2.   Problem Definition
3.   Contributions of Update
4.   Instance-Level Update: Details
5.   Intensional-Level Update: Details
6.   Conclusion

                                         21/28
Intensional-level Update
   Insertion of F may yield disjunctive
    information in the ABox. This:
          is not expressible in DL-Lite
          increases complexity of reasoning
   We address this problem by means of
    prioritization over predicates



                                               22/28
Intensional-level Update
   Basic steps of update are similar to those
    of instance-level update, but:
          The goal is to compute both T' and A' such that
           models are changed minimally
          Satisfiability is checked not for T and F, but for
           unchanged subset TPr of T and F
          Changes in TBox in general affect ABox
          Implicit assertions within TBox should be taken
           into account
          Building contradictory sets must be done with
           respect to prioritization
                                                                23/28
  TBox Update Algorithm
              Employee
                                                             AreaManager ⊑ Manager
          empCode: Integer    1..*                           TopManager ⊑ AreaManager
          salary: Integer


                                     worksFor
                                                             TopManager(frank)
 boss                                   ▼                    AreaManager(frank)
  ▼
              Manager                       Project          F= {TopManager ⊑ ¬ AreaManager }
                                                             F= AreaManager ⊑ ¬ TopManager
                                       projectName: String




                                                  1..1
                                     manages
                                       ▲

AreaManager                  TopManager
                                                  1..1



                                                                                                24/28
  TBox Update Algorithm
              Employee
                                                             AreaManager ⊑ Manager
          empCode: Integer    1..*                           TopManager ⊑ AreaManager
          salary: Integer


                                     worksFor
                                                             TopManager(frank)
 boss                                   ▼                    AreaManager(frank)
  ▼
              Manager                       Project          F= {TopManager ⊑ ¬ AreaManager
                                                             F= AreaManager ⊑ ¬ TopManager }
                                       projectName: String




                                                  1..1
                                                             T–= {TopManager ⊑ AreaManager}
                                     manages
                                       ▲

AreaManager                  TopManager
                                                  1..1



                                                                                               24/28
  TBox Update Algorithm
              Employee
                                                             AreaManager ⊑ Manager
          empCode: Integer    1..*                           TopManager ⊑ AreaManager
          salary: Integer


                                     worksFor
                                                             TopManager(frank)
 boss                                   ▼                    AreaManager(frank)
  ▼
              Manager                       Project          F= {TopManager ⊑ ¬ AreaManager
                                                             F= AreaManager ⊑ ¬ TopManager }
                                       projectName: String




                                                  1..1
                                                             T–= {TopManager ⊑ AreaManager}
                                     manages                 P: TopManager >Pr AreaManager
                                       ▲
                                                             A–= {AreaManager(frank)}
AreaManager                  TopManager
                                                  1..1



                                                                                               24/28
  TBox Update Algorithm
              Employee
                                                             AreaManager ⊑ Manager
          empCode: Integer    1..*                           TopManager ⊑ AreaManager
                                                                           ¬ AreaManager
          salary: Integer
                                                             TopManager ⊑ Manager
                                     worksFor
                                                             TopManager(frank)
 boss                                   ▼                    AreaManager(frank)
  ▼
              Manager                       Project          F= {TopManager ⊑ ¬ AreaManager
                                                             F= AreaManager ⊑ ¬ TopManager }
                                       projectName: String




                                                  1..1
                                                             T–= {TopManager ⊑ AreaManager}
                                     manages                 P: TopManager >Pr AreaManager
                                       ▲
                                                             A–= {AreaManager(frank)}
AreaManager                  TopManager
               {disjoint}
                                                  1..1



                                                                                               24/28
TBox Update Algorithm
 The size of T' and A' is polynomially
  bounded by the size of T ∪ A ∪ F.
 Computing T' and A' can be done in
  polynomial time in the size of T ∪ A ∪ F.




                                              25/28
Outline
1.   Ontologies and Description Logics
2.   Problem Definition
3.   Contributions of Update
4.   Instance-Level Update: Details
5.   Intensional-Level Update: Details
6.   Conclusion

                                         26/28
Main Contributions
   We considered two types of update:
       Instance-level update
       Intensional-level update

   Our main contributions are:
          Polynomial time algorithm for instance-level
           update for DL-LiteA
          Polynomial time algorithm for intensional-level
           update for DL-LiteFR

                                                             27/28
Further Research
   Implementation of the presented
    algorithms
   To consider other approaches to update
   Prioritization for intensional-level algorithm
    could be improved



                                                     28/28
Thank you!

								
To top