The Semantic Web

Document Sample
The Semantic Web Powered By Docstoc
					       The Semantic Web:
Means Many Things to Many People
 What is the Semantic Web?

The Semantic Web is an evolving extension of the World Wide Web
in which web content can be expressed not only in natural language,
but also in a form that can be understood, interpreted and used by
software agents, thus permitting them to find, share and integrate
information more easily.

It derives from W3C director Tim Berners-Lee's vision of the Web as
a universal medium for data, information, and knowledge exchange.
The Story
   The Layer Cake
of the Semantic Web
Ontology Language ~ OSM/OWL
                                                         <owl:Ontology>
                                                         …
Name
       1:*     1
                   Italian                 ItalianProf
                                                         <owl:Class rdf:ID=“Italian”>
         has                                                 <owl:unionOf rdf:parseType=“owl:collection”>
                                                               <owl:Class ref:resource=“#Lazy”/>
                                                               <owl:Class ref:resource=“#Mafioso”/>
                                                               <owl:Class ref:resource=“#LatinLover”/>
       Lazy        Mafioso   LatinLover
                                                             …
        Lazy(x) => not ItalianProf(x)                        <owl:Restriction>
        ItalianProf(x) => not Lazy(x)
        Mafioso(x) => not ItalianProf(x)                       <owl:onProperty rdf:resource=“#hasName”/>
        ItalianProf(x) => not Mafioso(x)
                                                               <owl:minCardinality>
                                                                  <rdf:datatype=“&xsd:#nonNegativeInteger”>1</…>
                                                               </owl:minCardinality>
                                                               <owl:maxCardinality>
                                                                  …
                                                         <owl:Class rdf:ID=“LatinLover”>
                                                             <rdfs:subClassOf rdf:resource=“#Italian”/>
                                                             <owl:disjointWith rdf:resource=“#Lazy”/>
                                                             <owl:disjointWith rdf:resource=“#Mafioso”/>
                                                         …
                                                         <owl:ObjectProperty rdf:ID=“hasName”>
                                                             <rdfs:domain rdf:resource=“#Italian”/>
                                                             <rdfs:range rdf:resource=“#Name”/>
                                                         ...
OSM/OWL & Logic and Proof

• Allow modeling to be done ontologically
  (high level of abstraction)
• Then, systematically transform the
  application model into predicate
  calculus for use in reasoning.
     Transformation to
Predicate Calculus: Example
Generated Predicates
   Object Sets
       Room(x), Room Nr(x), Cost(x), Date(x), Guest(x), Guest Nr(x),
       Current Guest(x), Future Guest(x), Guarantee Nr(x)


   Relationship Sets
       Room(x) has Room Nr(y),
       Room(x) has Cost(y),
       Guest(x) has reservation for Room(y) on Date(z),
       Guest(x) has Guest Nr(y)
       Future Guest(x) has Guarantee Nr(y)
Generated Rules
 Referential-Integrity Constraints
     xy(Room(x) has Room Nr(y)  Room(x)  Room Nr(y))
     ...
 Generalization/Specialization Constraints
     x(Current Guest(x)  Future Guest(x)  Guest(x))

 Participation Constraints
     x(Room(x)  1y(Room(x) has Cost(y))
     x(Cost(x) 1y(Room(y) has Cost(x))
     ...
 Co-occurrence Constraints
     <x, y>(z(Guest(z) has reservation for Room(x) on Date(y))
         1w(Guest(w) has reservation for Room(x) on Date(y)))
         A Valid Interpretation
Object-Set Relations
       Room      Room Nr            Cost   ...
       R1        1                  90
       R2        2                  80

Relationship-Set Relations
       Room has Room Nr       ...
       R1       1
       R2       2

Constraints
       x(Room(x)  1y(Room(x) has Room Nr(y))
       ...
                          Logic and Proof
                                                                           1:*     1
                                                                    Name               Italian            ItalianProf
                                                                             has


Prove: ItalianProf(x)  LatinLover(x)
Proof (by contradiction):                                                  Lazy        Mafioso   LatinLover
  1.    LatinLover(x)              negation of conclusion      Lazy(x) => not ItalianProf(x)
  2.    ItalianProf(x)              premise                     ItalianProf(x) => not Lazy(x)
                                                                Mafioso(x) => not ItalianProf(x)
  3.    ItalianProf(x)  Italian(x) ontologically given         ItalianProf(x) => not Mafioso(x)


  4.    Italian(x)                  modus ponens (2&3)
  5.    Italian(x)  Lazy(x)  Mafioso(x)  LatinLover(x)       ontologically given
  6.    Lazy(x)  Mafioso(x)  LatinLover(x)           modus ponens (4&5)
  7.    Lazy(x)  Mafioso(x)        resolution (1&6)
  8.    ItalianProf(x)  Lazy(x) ontologically given
  9.    Lazy(x)                    modus ponens (2&8)
  10.   Mafioso(x)                  resolution (7&9)
  11.   Mafioso(x)  ItalianProf(x)         ontologically given
  12.   ItalianProf(x)             modus ponens (10&11)
  13.   F                           contradiction (2&12)
    RDF & RDFS ~ the Heart of OWL
•   RDF (Resource Description Framework)
     – A triple model where every assertion is decomposed in three parts: (subject,
       predicate, object) for instance (tutorial.php, author, "Fabien").
     – The subject is a URI identifying a resource. The predicate is a binary relation
       identified by a URI. The object is either a URI identifying a resource or a literal
       value.
     – Each triple can be seen as a labeled arc and joining these arcs one obtains a
       graph that describes URI-identified resources and their relations.

•   RDFS (RDF Schema)
     – RDFS is a set of primitives to describe lightweight ontologies
     – RDFS allows us to:
          • name and declare a vocabulary (name resource types and binary relation types called
            properties);
          • specify the signature of properties (type of the domain i.e. type of the subject and type
            of the range i.e. type of the object);
          • specify the (multiple)-inheritance links between the types of classes (subClassOf);
          • specify the (multiple)-inheritance links between the types of properties (subPropertyOf);
                                  RDF Graph
                                  (How to think about RDF)

                                     gc:Marriage
“Sarah /Baker/”                                                                  “Mark /Baker/”

   gc:name                             rdf:type                                    gc:name

    #sarah           gc:married      #marriage                  gc:married             #mark
                                                                                                       rdf:type
                                               gc:place        “Boston”
                                        gc:date
                                                          “December 22, 1868”

                                         rdf:type                                                        gc:Individual


      gc:gaveBirth                                                           gc:fathered

                                   #birthOfSamuel                                      rdf:type
                                                                             gc:born

                                               gc:place         “Chicago”
                                                                                           gc:gender         “M”
                  gc:Birth        rdf:type
                                             gc:date
                                                              “April 17, 1873”
                                                                                           gc:name     “Samuel /Baker/”


                                                                                   #samuel
                       SPARQL
                 (An RDF Query Language)
• Specifies queries over an RDF triple store

• Triple stores have an OWL/RDF schema

• Example: get names and, if available, gender and
  birthdate of people born in the 1870’s.

      SELECT ?Name ?Gender ?BirthDate
      WHERE { ?IndividualURI gc:name ?Name .
              OPTIONAL { ?IndividualURI gc:gender ?Gender ;
                                   gc:born ?Birth .
                           ?Birth gc:date ?BirthDate } .
               FILTER REGEX(?BirthDate, "187\\d") }
Genesis

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:5
posted:8/29/2012
language:simple
pages:15