Semantic Web 101

1
Semantic Web 101

• Sean Bechhofer
• University of Manchester, UK

sean.bechhofer_at_manchester.ac.uk http//www.cs.man
chester.ac.uk/people/bechhofer
2
The Semantic Web Vision

• The Web was made possible through established
  standards
• TCP/IP for transporting bits down a wire
• HTTP HTML for transporting and rendering
  hyperlinked text
• Applications able to exploit this common
  infrastructure
• Result is the WWW as we know it
• 1st generation web mostly handwritten HTML pages
• 2nd generation (current) web often machine
  generated/active
• Both intended for direct human processing/interact
  ion
• In the next generation web, resources should be
  more accessible to automated processes
• To be achieved via semantic markup
• Metadata annotations that describe
  content/function
• Coincides with Tim Berners-Lee's vision of a
  Semantic Web

3
History of the Semantic Web

• Web was invented by Tim Berners-Lee (amongst
  others), a physicist working at CERN
• TBLs original vision of the Web was much more
  ambitious than the reality of the existing
  (syntactic) Web
• A number of researchers have since been working
  towards realising this vision, which has become
  known as the Semantic Web
• E.g., article in May 2001 issue of Scientific
  American

... a goal of the Web was that, if the
interaction between person and hypertext could be
so intuitive that the machine-readable
information space gave an accurate representation
of the state of people's thoughts, interactions,
and work patterns, then machine analysis could
become a very powerful management tool, seeing
patterns in our work and facilitating our working
together through the typical problems which beset
the management of large organizations.
4
The Semantic Web Hype Cycle
Semantic Webc. 2004
Visibility
TechnologyTrigger
Peak of InflatedExpectation
Trough ofDisillusionment
Slope ofEnlightenment
Plateau ofProductivity
Maturity
Gartner
5
(No Transcript)
6
(No Transcript)
7
(No Transcript)
8
Describing the Semantic Web

• Its the Web of Data. Data is whats in
  databases. Imagine its linked up like documents
  are linked up on the Web
• Imagine a spreadsheet where you can import data
  about anything from anywhere
• RDF is to data what HTML is to documents

9
Scientific American, May 2001

• Realising the complete vision is too hard for
  now (probably)
• But we can make a start by adding semantic
  annotation to web resources

10
Need to Add Semantics

• External agreement on meaning of annotations
• E.g., Dublin Core for annotation of
  library/bibliographic information
• Agree on the meaning of a set of annotation tags
• Problems with this approach
• Inflexible
• Limited number of things can be expressed
• Use Ontologies to specify meaning of annotations
• Ontologies provide a vocabulary of terms
• New terms can be formed by combining existing
  ones
• Conceptual Lego
• Meaning (semantics) of such terms is formally
  specified
• Can also specify relationships between terms in
  multiple ontologies

Machine Processable not Machine Understandable
11
RDF

• RDF stands for Resource Description Framework
• It is a W3C Recommendation
• http//www.w3.org/RDF
• RDF is a graphical formalism ( XML syntax
  semantics)
• for representing metadata
• for describing the semantics of information in a
  machine- accessible way
• Provides a simple data model based on triples.

12
The RDF Data Model

• Statements are ltsubject, predicate, objectgt
  triples
• ltSean,hasColleague,Iangt
• Can be represented as a graph
• Statements describe properties of resources
• A resource is any object that can be pointed to
  by a URI
• The generic set of all names/addresses that are
  short strings that refer to resources
• a document, a picture, a paragraph on the Web,
  http//www.cs.man.ac.uk/index.html, a book in the
  library, a real person (?), isbn//0141184280
• Properties themselves are also resources (URIs)

13
Linking Statements

• The subject of one statement can be the object of
  another
• Such collections of statements form a directed,
  labeled graph
• The object of a triple can also be a literal (a
  string)

Sean K. Bechhofer
hasName
hasColleague
Sean
Ian
hasHomePage
hasColleague
http//www.cs.man.ac.uk/horrocks
Carole
14
RDF Syntax

• RDF has an XML syntax that has a specific
  meaning
• Every Description element describes a resource
• Every attribute or nested element inside a
  Description is a property of that Resource
• We can refer to resources by URIs

15
ltrdfDescription rdfabout"some.uri/person/sean_b
echhofer"gt ltohasColleague resource"some.uri/pe
rson/ian_horrocks"/gt ltohasName
rdfdatatype"xsdstring"gtSean K.
Bechhoferlt/ohasNamegt lt/rdfDescriptiongt ltrdfDesc
ription rdfabout"some.uri/person/ian_horrocks"gt
ltohasHomePagegthttp//www.cs.mam.ac.uk/horrocks
lt/ohasHomePagegt lt/rdfDescriptiongt ltrdfDescripti
on rdfabout"some.uri/person/carole_goble"gt
ltohasColleague resource"some.uri/person/ian_horr
ocks"/gt lt/rdfDescriptiongt
16
What does RDF give us?

• A mechanism for annotating data and resources.
• Single (simple) data model.
• Syntactic consistency between names (URIs).
• Low level integration of data.

17
RDF(S) RDF Schema

• RDF gives a formalism for meta data annotation,
  and a way to write it down in XML, but it does
  not give any special meaning to vocabulary such
  as subClassOf or type (supporting OO-style
  modelling)
• Interpretation is an arbitrary binary relation
• RDF Schema extends RDF with a schema vocabulary
  that allows you to define basic vocabulary terms
  and the relations between those terms
• Class, type, subClassOf,
• Property, subPropertyOf, range, domain
• it gives extra meaning to particular RDF
  predicates and resources
• this extra meaning, or semantics, specifies how
  a term should be interpreted

18
RDF(S) Inference
19
RDF(S) Inference
20
What does RDF(S) give us?

• Ability to use simple schema/vocabularies when
  describing our resources.
• Consistent vocabulary use and sharing.
• Simple inference
• CS AktiveSpace
• Lightweight schema to integrate data from
  University sites
• myGrid
• Service descriptions for e-Science

21
Problems with RDFS

• RDFS is too weak to describe resources in
  sufficient detail
• No localised range and domain constraints
• Cant say that the range of hasChild is person
  when applied to persons and elephant when applied
  to elephants
• No existence/cardinality constraints
• Cant say that all instances of person have a
  mother that is also a person, or that persons
  have exactly 2 parents
• No transitive, inverse or symmetrical properties
• Cant say that isPartOf is a transitive property,
  that hasPart is the inverse of isPartOf or that
  touches is symmetrical
• It can be difficult to provide reasoning support
• No native reasoners for non-standard semantics
• May be possible to reason via FO axiomatisation

22
Ontology in Computer Science

• An ontology is an engineering artifact
• It is constituted by a specific vocabulary used
  to describe a certain reality, plus
• a set of explicit assumptions regarding the
  intended meaning of the vocabulary.
• Almost always including how concepts should be
  classified
• Thus, an ontology describes a formal
  specification of a certain domain
• Shared understanding of a domain of interest
• Formal and machine manipulable model of a domain
  of interest

23
Building a Semantic Web

• Annotation
• Associating metadata with resources
• Integration
• Integrating information sources
• Inference
• Reasoning over the information we have.
• Could be light-weight (taxonomy)
• Could be heavy-weight (logic-style)
• Interoperation and Sharing are key goals

24
Languages

• Work on Semantic Web has concentrated on the
  definition of a collection or stack of
  languages.
• These languages are then used to support the
  representation and use of metadata.
• The languages provide basic machinery that we can
  use to represent the extra semantic information
  needed for the Semantic Web
• XML
• RDF
• RDF(S)
• OWL

25
The Semantic Web layer cake
User Interface and Applications
Trust
Attribution
Proof
Explanation
Rules
OWL
SPARQL(queries)
Ontologies Inference
RDF Schema
RDF
Metadata
XML Namespaces
Standard syntax
URI
Unicode
Identity
26
Ontology Languages

• We need languages that allow us to represent this
  information
• Ontology Languages!
• There are a wide variety of languages for this
  Explicit Specification
• Graphical
• Semantic Networks, Topic Maps, UML, RDF
• Logical
• Description Logics, First Order Logic, Rules,
  Conceptual Graphs

mother(X,M) - parent(X,M), female(M). father(X,F)
- parent(X,F), male(F). sister(X,S) -
female(S), parent(S,P), parent(X,P), X \
S. male(james1). male(charles1). male(charles2).
male(james2). male(george1). female(catherine). fe
male(elizabeth). female(sophia). parent(charles1,
james1). parent(elizabeth, james1). parent(charles
2, charles1). parent(catherine,
charles1). parent(james2, charles1). parent(sophia
, elizabeth). parent(george1, sophia).
Every gardener likes the sun 8x.gardener(x) )
likes(x, Sun) You can fool some of the people all
of the time 9x.8t.(person(x) Æ time(t)) )
can-fool(x,t) You can fool all of the people some
of the time 8x.9t.(person(x) Æ time(t)) )
can-fool(x,t) All purple mushrooms are poisonous
8x.(mushroom(x) Æ purple(x)) ) poisonous(x) No
purple mushroom is poisonous 9x.(mushroom(x)
Æ purple(x) Æ poisonous(x)) 8x.(mushroom(x) Æ
purple(x)) ) poisonous(x) There are exactly two
purple mushrooms 9x.9y.mushroom(x) Æ purple(x)
Æ mushroom(y) Æ purple(y) Æ (xy) Æ
(8x.mushroom(z) Æ purple(z) ) ((xz) _
(yz))) Clinton is not tall tall(Clinton)
27
Object Oriented Models

• Many languages use an object oriented model
  with
• Objects/Instances/Individuals
• Elements of the domain of discourse
• Equivalent to constants in FOL
• Types/Classes/Concepts
• Sets of objects sharing certain characteristics
• Equivalent to unary predicates in FOL
• Relations/Properties/Roles
• Sets of pairs (tuples) of objects
• Equivalent to binary predicates in FOL
• Such languages are/can be
• Well understood
• Formally specified
• (Relatively) easy to use
• Amenable to machine processing

28
Why (Formal) Semantics?

• Increased formality makes languages more amenable
  to machine processing (e.g. automated reasoning).
• The formal semantics provides an unambiguous
  interpretation of the descriptions.
• What does an expression in an ontology language
  mean?
• The semantics of a language tell us precisely how
  to interpret a complex expression.
• Well defined semantics are vital if we are to
  support machine interpretability
• They remove ambiguities in the interpretation of
  the descriptions.

Black
Telephone
?
29
Web Ontology Language Requirements

• Desirable features identified for Web Ontology
  Language
• Extends existing Web standards
• Such as XML, RDF, RDFS
• Easy to understand and use
• Should be based on familiar KR idioms (e.g.
  OO-style, frames etc).
• Formally specified
• Of adequate expressive power
• Possible to provide automated reasoning support

30
The OWL Family Tree
DAML
RDF/RDF(S)
DAML-ONT
Joint EU/US Committee
DAMLOIL
OWL
Frames
OIL
W3C
OntoKnowledgeOthers
Description Logics
31
OWL

• W3C Recommendation (February 2004)
• Well defined RDF/XML serializations
• A family of Languages
• OWL Full
• OWL DL
• OWL Lite
• Formal semantics
• First Order (DL/Lite)
• Relationship with RDF
• Comprehensive test cases for tools/implementations
  
• Growing industrial takeup.

32
OWL Basics

• Set of constructors for concept expressions
• Booleans and/or/not
• Quantification some/all
• Axioms for expressing constraints
• Necessary and Sufficient conditions on classes
• Disjointness
• Property characteristics transitivity, inverse
• Facts
• Assertions about individuals

33
Reasoning with OWL

• OWL (DL) has a well defined semantics that tells
  us how to interpret expressions in the language.
• This semantics corresponds to traditional
  interpretations given to first order logic or
  subsets of FOL like Description Logics.
• OWL DL based on a well understood Description
  Logic (SHOIN(Dn))
• Formal properties well understood (complexity,
  decidability)
• Known reasoning algorithms
• Implemented systems (highly optimised)
• Because of this, we can reason about OWL
  ontologies, allowing us to draw inferences from
  the basic facts that we provide.

34
Reasoning Tasks
Sean Bechhofer Concrete Examples Grid/VO? GONG?

• Subsumption reasoning
• Allows us to infer when one class is a subclass
  of another
• Can then build concept hierarchies representing
  the taxonomy.
• This is classification of classes.
• Satisfiability reasoning
• Tells us when a concept is unsatisfiable
• i.e. when it is impossible to have instances of
  the class.
• Allows us to check whether our model is
  consistent.
• Instance Retrieval/Instantiation
• What are the instances of a particular class C?
• What are the classes that x is an instance of?

35
Classification
36
Why Reasoning?

• Reasoning can be used as a design support tool
• Check logical consistency of classes
• Compute implicit class hierarchy
• May be less important in small local ontologies
• Can still be useful tool for design and
  maintenance
• Much more important with larger
  ontologies/multiple authors
• Valuable tool for integrating and sharing
  ontologies
• Use definitions/axioms to establish
  inter-ontology relationships
• Check for consistency and (unexpected) implied
  relationships
• Basis for answering queries.
• Reasoning can help underpin the provision of the
  machine processing required of the Semantic Web.

37
What does OWL give us?

• Rich language for describing domain models.
• Unambiguous interpretations of complex
  descriptions.
• The ability to use inference to manage our
  vocabularies.
• GONG
• VO Formation
• PhosphaBase

38
More Languages

• RDF, RDF(S) and OWL provide basic
  representational capabilities.
• We also need mechanisms that allow us to access
  and query the information.
• RDF has an underlying concrete syntax based on
  XML. Why not just use something like XPath to
  query the RDF?
• RDQL, RQL, SeRQL,
• W3C Data Access Working Group attempting to
  standardise on SPARQL
• Elements of the earlier languages with a
  well-defined semantic basis
• OWL-QL Query language for OWL.
• Allow specification of conjunctive queries using
  OWL concept expressions
• Also investigations into extensions of the
  expressivity of OWL.
• Rules

39
Potential Pitfalls
40
Conflicting Views

• The Semantic Web community is diverse, with a
  rough division between the neats and the
  scruffies.

• Neats
• Logic and languages
• Completeness/decidability
• Top down, well-behaved
• Heavyweight
• Rich ontologies
• OWL

• Scruffies
• Practice
• Bottom up/real-world
• Lightweight
• Folksonomies
• FOAF
• RDF

41
Semantic Web vs Semantic Web

• Semantics/AI/KR community with little attention
  paid to Web aspects
• Youre not doing it properly
• Web community with little attention paid to
  Semantics.
• Just stick everything in a big RDF store and
  itll all be fine
• Diversity can be healthy, but can also lead to
  fragmentation and pointless arguments.

Splitters!
42
Tools and Services

• We need to provide tools and services to help
  users to
• Design and maintain high quality ontologies,
  e.g.
• Meaningful all named classes can have instances
• Correct captured intuitions of domain experts
• Minimally redundant no unintended synonyms
• Richly axiomatised (sufficiently) detailed
  descriptions
• Store (large numbers) of instances of ontology
  classes, e.g.
• Annotations from web pages
• Answer queries over ontology classes and
  instances, e.g.
• Find more general/specific classes
• Retrieve annotations/pages matching a given
  description
• Integrate and align multiple ontologies

43
How thick is your infrastructure?

• Sharing is about interoperations. Ensuring that
  when you look at or process my data, you do it in
  a consistent way.
• Thick infrastructure can help interoperability.
  Clients dont have to guess how to interpret
  things.
• But can be harder to build

Thin Apps
Thin Apps
Thick Infrastructure
44
How thick is your infrastructure?

• A lightweight infrastructure (e.g. RDF) means
  that clients/apps have to do more. And may do it
  differently.
• Metadata can end up being locked away within the
  applications where others cant get at it. Is
  that sharing? Are you exposing the semantics?

Thick Apps
Thick Apps
Thin Infrastructure
45
Trust and Security

• Publishing my information in machine-processable
  forms may allow you to
• Work out what Im doing
• Integrate across multiple sources to produce new
  conclusions
• How do I control this?
• We need mechanisms that will allow us to control
  access to knowledge
• We need mechanisms that allow us to ascribe
  provenance and trust information to our
  knowledge.
• The SW stack sees these at the top. Some of
  this has to come from the bottom though.

46
Scalability

• Will this stuff work on a web scale?
• Millions of triples/fact
• Thousands of ontologies
• Are you ever going to get global agreements?

47
Language Summary

• Weve seen some of the technology being proposed
  as a basis for building the Semantic Web
• These languages provide basic machinery that we
  can use to represent the extra semantic
  information needed for the Semantic Web
• XML
• RDF
• RDF(S)
• OWL

48
Thanks Sean!