China 2009 语义网与本体技术系列讲座 III 专题研究 Research Topics 黄智生 Zhisheng Huang Vrije University Amsterdam The Netherlands [email protected]

China 2009 http://www.larkc.eu/ 1

语义网与本体技术系列讲座 III专题研究

Research Topics

黄智生

Zhisheng Huang

Vrije University Amsterdam

The Netherlands

[email protected]


语义网与本体技术系列讲座

• 第一部分：导论2009 年 9 月 9 日星期三 14 ： 00-15 ： 30

• 第二部分：逻辑基础2009 年 9 月 12 日星期六 10 ： 00-11 ： 30

• 第三部分：专题研究2009 年 9 月 13 日星期日 9 ： 00-10 ： 30

------------------------------------------------------------ LarKC 人员专题讨论2009 年 9 月 13 日星期日 14 ： 00-15 ： 30


Outline

• 本体推理与管理 (Reasoning and Management of Ontologies)

• 不一致性本体的推理（ Reasoning with Inconsistent Ontologies)

• 海量语义数据推理 (Scalable Reasoning)

• 结论和讨论 (Conclusion and Discussion)


Change

Query Answer

Query Answer

Diagnosis and Repair

Reasoningwith inconsistent ontologies

Incremental Ontology Evolution

+

+

=

=

+ =

Ontology Reasoning and Inconsistency Management


Inconsistency and the Semantic Web

• The Semantic Web is characterized by

• scalability,

• distribution, and

• multi-authorship

• All these may introduce inconsistencies.


Ontologies will be inconsistent

Because of:

• mistreatment of defaults

• polysemy

• migration from another formalism

• integration of multiple sources

• …

(“Semantic Web as a wake-up call for KR”)


Example: Inconsistency by mistreatment of default

rulesMadCow Ontology• Cow Vegetarian• MadCow Cow• MadCow Eat.BrainofSheep• Sheep Animal• Vegetarian Eat. (Animal PartofAnimal)• Brain PartofAnimal• ......• theMadCow MadCow• ...


Example: Inconsistency through imigration

from other formalism

DICE Ontology

• Brain CentralNervousSystem• Brain BodyPart• CentralNervousSystem NervousSystem• BodyPart NervousSystem


Inconsistency and Explosion

• The classical entailment is explosive:P, ¬ P |= Q

Any formula is a logical consequence of a contradiction.

• The conclusions derived from an inconsistent ontology using the standard reasoning may be completely meaningless


Why DL reasoning cannot escape the explosion

• The derivation checking is usually achieved by the satisfiability checking.

|= {¬} is not satisfiable.

• Tableau algorithms are approaches based on the satisfiability checking

is inconsistent => is not satisfiable => {¬} is not satisfiable.


Two main approaches to deal with inconsistency

• Inconsistency Diagnosis and Repair• Ontology Diagnosis(Schlobach and Cornet 2003)

• Reasoning with Inconsistency• Paraconsistent logics• Limited inference (Levesque 1989)• Approximate reasoning(Schaerf and Cadoli 1995)• Resource-bounded inferences(Marquis et al.2003)• Belief revision on relevance (Chopra et al. 2000)


What an inconsistency reasoner is expected

• Given an inconsistent ontology, return meaningful answers to queries.

• General solution: Use non-standard reasoning to deal with inconsistency

|= : the standard inference relations

| : nonstandard inference relations


Reasoning with inconsistent ontologies: Main Idea

Starting from the query, 1. select consistent sub-theory by using a

relevance-based selection function.

2. apply standard reasoning on the selected sub-theory to find meaningful answers.

3. If it cannot give a satisfying answer, the selection function would relax the relevance degree to extend consistent sub-theory for further reasoning.


New formal notions are needed

• New notions:• Accepted:• Rejected:• Overdetermined:• Undetermined:

• Soundness: (only classically justified results)

• Meaningfulness: (sound & never overdetermined)

soundness +


• Soundness: | =>` (` consistent and `|=).

• Meaningfulness: sound and consistent ( | => ¬).

• Local Completeness w.r.t a consistent ` : (`|= => |).

• Maximality: locally complete w.r.t a maximal consistent set `.

• Local Soundness w.r.t.a consistent set `: | => `|=).

Some Formal Definitions


Selection Functions

Given an ontology T and a query , a selection function s(T,,k)returns a subset of the ontology at each step k>0.


General framework

Use selection function s(T,,k),with s(T,,k) s(T,,k+1)

1. Start with k=0: s(T,,0) |= or s(T,,0) |= ?

2. Increase k, untils(T,,k) |= or s(T,,k) |=

3. Abort when• undetermined at maximal k• overdetermined at some k


Inconsistency Reasoning Processing: Linear

Extension


Proposition: Linear Extension

• Never over-determined• May undetermined• Always sound• Always meaningful• Always locally complete• May not maximal• Always locally sound


Direct Relevance and K Relevance

• Direct relevance (0-relevance). • there is a common name in two formulas:

C() C() R() R() I() I().

• K-relevance: there exist formulas 0, 1,…, k such that

and 0, 0 and 1 , …, k and

are directly relevant.


Relevance-based Selection Functions

• s(T,,0)=• s(T,,1)=

{ T: is directly relevant to }.

• s(T,,k)= { T: is directly relevant to s(T,,k-1)}.


PION Prototype

PION: Processing Inconsistent ONtologies

http://wasp.cs.vu.nl/sekt/pion


An Extended DIG Description Logic Interface

for Prolog (XDIG)• A logic programming infrastructure

for the Semantic Web

• Similar to SOAP

• Application independent, platform independent

• Support for DIG clients and DIG servers.


XDIG

• As a DIG client, the Prolog programs can call any external DL reasoner which supports the DIG DL interface.

• As a DIG server, the Prolog programs can serve as a DL reasoner, which can be used to support additional reasoning processing, like inconsistency reasoning multi-version reasoning, and inconsistency diagnosis and repair.


XDIG package

• The XDIG package and the source code are now available for public download at the website: http://wasp.cs.vu.nl/sekt/dig/

• In the package, we offer five examples how XDIG can be used to develop extended DL reasoners.


PION Testbed


Answer Evaluation

• Intended Answer (IA): PION answer = Intuitive Answer

• Cautious Answer (CA): PION answer is ‘undetermined’, but intuitive answer is ‘accepted’ or ‘rejected’.

• Reckless Answer (RA): PION answer is ‘accepted’ or ‘rejected’, but intuitive answer is ‘undetermined’.

• Counter Intuitive Answer (CIA): PION answer is ‘accepted’ but intuitive answer is ‘rejected’, or vice verse.


Preliminary Tests with Syntactic-relevance Selection Function

Ontology Queries IA CA RA CIA IA (%)

ICR (%)

Bird 50 50 0 0 0 100 100

Brain (DICE)

42 36 4 2 0 85.7 100

MarriedWoman

50 48 0 2 0 96 100

MadCow 254 236 16 0 2 92.9 99


Intensive Tests on PION

• Evaluation and test on PION with several realistic ontologies:• Communication Ontology• Transportation Ontology • MadCow Ontology

Each ontology has been tested by thousands of queries with different selection functions.


Summary

• we proposed a general framework for reasoning with inconsistent ontologies

• based on selecting ever increasing consistent subsets

• choice of selection function is crucial• query-based selection functions are

flexible to find intended answers• simple syntactic selection works

surprisingly well


Extension

•Semantic Relevance Based Selection Functions

•K-extension

• Variants of over-determined processing strategies

• Integrating with the diagnosis approach

http://www.larkc.eu/ 32

Using Semantic Distances for Reasoning with Inconsistent

Ontologies

• Google distances are used to develop semantic relevance functions to reason with inconsistent ontologies.

• Assumption: two concepts appear more frequently in the same web page, they are semantically more similar (relevant).


Google Distances (Cilibrasi and Vitanyi 2004)

• Google distance is measured in terms of the co-occurrence of two search items in the Web by Google search engine.

• Normalized Google Distance (NGD) is introduced to measure the similarity/light-weight semantic relevance

• NGD(x,y)= (max{log f(x), log f(y)}-log f(x,y))/(log M-min{log f(x),log f(y)}

where

f(x) is the number of Google hits for x

f(x,y) is the number of Google hits for the tuple of search items x and y

M is the number of web pages indexed by Google.


Semantic Distances

• Define semantic distances (SD) between two formulas in terms of semantic distances between two concepts/roles/individuals (NGD)


Postulates for Semantic Distances


Semantic Distances

Semantic distance are measured by the ratio of the summed distance of the difference between two formulae to the maximal distance between two formulae.


Proposition

• The semantic distance SD satisfies the properties Range, Reflexivity, Symmetry, Maximum Distance, and Intermediate Values.


Example: MadCow

NGD(MadCow, Grass)=0.7229

NGD(MadCow, Sheep)=0.6120


Implementation: PION

PION: Processing Inconsistent ONtologies

http://wasp.cs.vu.nl/sekt/pion


Answer Evaluation• Intended Answer (IA):

Query answer = Intuitive Answer • Cautious Answer (CA):

Query answer is ‘undetermined’, but Intutitve answer is ‘accepted’ or ‘rejected’.

• Reckless Answer (RA): Query answer is ‘accepted’ or ‘rejected’, but Intutive answer is ‘undetermined’.

• Counter Intuitive Answer (CIA): Query answer is ‘accepted’ but Intuitive answer is ‘rejected’, or vice versa.


Syntactic approach vs. Semantic approach: quality

of query answers


Syntactic approach vs. Semantic approach: Time Performance


Summary

• The run-time of the semantic approach is much better than the syntactic approach, while the quality remains comparable.

• The semantic approach can be parameterised so as to stepwise further improve the run-time with only a very small drop in quality.


Summary (cont.)

• The semantic approach for reasoning with inconsistent ontologies trade-off computational cost for inferential completeness, and provide attractive scalability.


LarKC: 一个海量语义数据处理平台

• The Large Knowledge Collider ( 大型知识对撞机）

A configurable platform

for experimentation

by others

• http://www.larkc.eu

http://www.larkc.eu/


可布局平台“ Configurable

platform”“a configurable platform for infinitely scalable semantic web reasoning”.

Enrich current logic-based Semantic Web reasoning with methods from information retrieval, machine learning, information theory, databases, and probabilistic reasoning


网络科学与人类智能科学的结合Web Science with Human

Intelligence• Employing cognitively inspired

approaches and techniques such as spreading activation, focus of attention, reinforcement, habituation, relevance reasoning, and bounded rationality


Achieve scalability through giving up

completeness • by giving up 100% correctness:

• trading quality for size• often completeness is not needed• sometimes even correctness is not needed

pre

cisi

on

(sou

ndn

ess

)

recall (completeness)

logic

IR

Semantic Web


通过并行计算达到海量数据处理能力Achieve Scalability through

Parallelization

• by parallelisation:• cluster computing

• wide area distribution “Thinking@home”, “self-computing semantic Web”

• cloud computing 云计算 (Amazon ， Google)


欧盟第七框架研究课题 : LarKCEU 7th framework Project

• 总预算 1 千万欧元： 10M€ budget • 历时 3 年半： 3.5 years• 八十个人年： 80 person years• 3 个实例研究： 3 case studies• 14 个合作单位： 14 partners,

来自 12 个国家： 12 countries,来自 3 大洲： 3 continents

• project nr. FP7 – 215535


The consortium

50 people present


The Consortium

• Combining consortium competence• IR, Cognition• ML, Ontologies• Statistics, ML,

Cognition,DB• Logic,DB,

Probabilistic Inference• Economics,

Decision Theory


课题组成Project Workpackages

WP1 – Conceptual Framework & Evaluation

WP 2: Retrieval and Selection

WP5: Collider Platform

WP

9:

Ex

plo

ita

tio

n a

nd

s

tan

da

rds

WP

10

: P

roje

ct

Ma

na

ge

me

nt

WP

8:

Tra

inin

g,

dis

se

min

ati

on

, c

om

mu

nit

y

bu

ild

ing

WP3: Abstraction and Learning

WP4: Reasoning and Deciding

WP 6: Use case: Real Time City

WP 7a: Use case: Early Clinical Development

WP 7b: Use case: Carcinogenesis

Reference Production


Use case: Drug Discovery

• Problem: pharmaceutical R&D in early clinical development is stagnating

(Q1Q2Q3)

FDA white paper Innovation or Stagnation (March 2004):

“developers have no choice but to use the tools of the last century to assess this century's candidate solutions.”

“industry scientists often lack cross-cutting information about anentire product area, or information about techniques that may be used in areas other than theirs”

FDA white paper Innovation or Stagnation (March 2004):

“developers have no choice but to use the tools of the last century to assess this century's candidate solutions.”

“industry scientists often lack cross-cutting information about anentire product area, or information about techniques that may be used in areas other than theirs”

“Show me any potential liver toxicity associated with the compound’s drug class, target, structure and disease.”

Show me all liver toxicity associated with the target or the pathway.

Genetics

1Q“Show me all liver toxicity associated with compounds with similar structure”

Chemistry

2Q

“Show me all liver toxicity from the public literature and internal reports that are related to the drug class, disease and patient population”LITERATURE

3Q

Current NCBI: linking but no inference


Use Case: Real Time City• Our cities face many challenges • Urban Computing

is the ICT way to address them

• How can we redevelop existing neighborhoods and business districts to improve the quality of life?

• How can we create more choices in housing, accommodating diverse lifestyles and all income levels?

• How can we reduce traffic congestion yet stay connected?

• How can we include citizens in planning their communities rather than limiting input to only those affected by the next project?

• How can we fund schools, bridges, roads, and clean water while meeting short-term costs of increased security?

• How can we redevelop existing neighborhoods and business districts to improve the quality of life?

• How can we create more choices in housing, accommodating diverse lifestyles and all income levels?

• How can we reduce traffic congestion yet stay connected?

• How can we include citizens in planning their communities rather than limiting input to only those affected by the next project?

• How can we fund schools, bridges, roads, and clean water while meeting short-term costs of increased security?

Is public transportation where the people are?Is public transportation where the people are?

Which landmarks attract more people?Which landmarks attract more people?

Where are people concentrating?Where are people concentrating?

Where is traffic moving?Where is traffic moving?


课题时间表 Project Timeline

• Surveys (plugins, platform)• Requirements (use cases)

Prototype Internal Release Public Release Final Release

Use Cases V1

Use Cases V2

Use Cases V3

420 6 18 3310


如果你对参与开发感兴趣的话How can any other interested party

contribute?• The Large Knowledge Collider is an

open, and configurable platform.

• The first public version of the Large Knowledge Collider is available.

• LarKC has formed an "early adapters group". LarKC will actively support this group in use the Large Knowledge Collider platform.


LarKC 中文论坛http://groups.google.com/group/larkc-

chinese-forum


Realising the Architecture

PipelineSupportSystem


Plug-in RegistryPlug-in

Registry

Plug-in ManagerPlug-in Manager

Data LayerData Layer

Plug-in APIPlug-in API

Data Layer APIData Layer APIRDF

StoreRDF

Store

59


Data Layer APIData Layer API



Plug-in RegistryPlug-in

Registry

RDFStoreRDF

StoreRDF

StoreRDF

StoreRDF

StoreRDF

StoreRDFDocRDFDoc

RDFDocRDFDoc

Data LayerData Layer

DeciderDecider



QueryTransformer

QueryTransformer



IdentifierIdentifier



Info. SetTransformer




SelecterSelecter



ReasonerReasoner


ApplicationApplication

RDFDocRDFDoc

Platform Utility Functionality

APIs

Plug-ins

External systems

External data sources

LarKC Architecture

60


LarKC Plug-in API: General Plug-in Model

• Plug-ins are identified by a URI (Uniform Resource Identifier)

• Plug-ins provide MetaData about what they do (Functional properties): e.g. type = Selecter

• Plug-ins provide information about their behaviour and needs, including Quality of Service information (Non-functional properties): e.g. Throughput, MinMemory, Cost,…

+ URI getIdentifier()+ QoSInformation getQoSInformation()

+ URI getIdentifier()+ QoSInformation getQoSInformation()

Plug-inPlug-in

Functional propertiesNon-functional propertiesWSDL description

Functional propertiesNon-functional propertiesWSDL description

Plug-in description

61


LarKC Plug-in API: IDENTIFY

• IDENTIFY: Given a query, identify resources that could be used to answer it• Sindice – Triple Pattern Query RDF Graphs

• Google – Keyword Query Natural Language Document

• Triple Store – SPARQL Query RDF Graphs

+ Collection<InformationSet> identify(Query theQuery, Contract contract, Context context)

+ Collection<InformationSet> identify(Query theQuery, Contract contract, Context context)

Identifier Identifier

62


LarKC Plug-in API: TRANSFORM (1/2)

• Query TRANSFORM: Transforms a query from one representation to another • SPARQL Query Triple Pattern Query

• SPARQL Query Keyword Query

• SPARQL Query SPARQL Query (different abstraction)

• SQARQL Query CycL Query

+ Set<Query> transform(Query theQuery, Contract theContract, Context theContext)+ Set<Query> transform(Query theQuery, Contract theContract, Context theContext)

QueryTransformerQueryTransformer

63


LarKC Plug-in API: TRANSFORM (2/2)

• Information Set TRANSFORM: Transforms data from one representation to another• Natural Language Document RDF Graph

• Structured Data Sources RDF Graph

• RDF Graph RDF Graph (e.g. foaf vocabulary to facebook vocabulary)

+ InformationSet transform(InformationSet theInformationSet, Contract theContract, Context theContext)

+ InformationSet transform(InformationSet theInformationSet, Contract theContract, Context theContext)

InformationSetTransformerInformationSetTransformer

64


LarKC Plug-in API: SELECT

• SELECT: Given a set of statements (e.g. a number of RDF Graphs) will choose a selection/sample from this set• Collection of RDF Graphs Triple Set (Merged)

• Collection of RDF Graphs Triple Set (10% of each)

• Collection of RDF Graphs Triple Set (N Triples)

+ SetOfStatements select(SetOfStatements theSetOfStatements, Contract contract,

Context context)

+ SetOfStatements select(SetOfStatements theSetOfStatements, Contract contract,

Context context)

SelecterSelecter

65


LarKC Plug-in API: REASON

• REASON: Executes a query against the supplied set of statements• SPARQL Query Variable Binding (Select)

• SPARQL Query Set of statements (Construct)

• SPARQL Query Set of statements (Describe)

• SPARQL Query Boolean (Ask)

+ VariableBinding sparqlSelect(SPARQLQuery theQuery, SetOfStatements theSetOfStatements, Contract contract, Context context)

+ SetOfStatements sparqlConstruct(SPARQLQuery theQuery, SetOfStatements theSetOfStatements, Contract contract, Context context)

+ SetOfStatements sparqlDescribe(SPARQLQuery theQuery, SetOfStatements theSetOfStatements, Contract contract, Context context)

+ BooleanInformationSet sparqlAsk(SPARQLQuery theQuery, SetOfStatements theSetOfStatements, Contract contract, Context context)

+ VariableBinding sparqlSelect(SPARQLQuery theQuery, SetOfStatements theSetOfStatements, Contract contract, Context context)

+ SetOfStatements sparqlConstruct(SPARQLQuery theQuery, SetOfStatements theSetOfStatements, Contract contract, Context context)

+ SetOfStatements sparqlDescribe(SPARQLQuery theQuery, SetOfStatements theSetOfStatements, Contract contract, Context context)

+ BooleanInformationSet sparqlAsk(SPARQLQuery theQuery, SetOfStatements theSetOfStatements, Contract contract, Context context)

ReasonerReasoner

66


LarKC Plug-in API: DECIDE

• DECIDE: Builds the pipeline and manages the control flow• Scripted Decider: Predefined pipeline is built and executed

• Self-configuring Decider: Uses plug-in descriptions (functional and non-functional properties) to build the pipeline

+ VariableBinding sparqlSelect(SPARQLQuery theQuery, QoSParameters theQoSParameters)

+ SetOfStatements sparqlConstruct(SPARQLQuery theQuery, QoSParameters theQoSParameters)

+ SetOfStatements sparqlDescribe(SPARQLQuery theQuery, QoSParameters theQoSParameters)

+ BooleanInformationSet sparqlAsk(SPARQLQuery theQuery, QoSParameters theQoSParameters)

+ VariableBinding sparqlSelect(SPARQLQuery theQuery, QoSParameters theQoSParameters)

+ SetOfStatements sparqlConstruct(SPARQLQuery theQuery, QoSParameters theQoSParameters)

+ SetOfStatements sparqlDescribe(SPARQLQuery theQuery, QoSParameters theQoSParameters)

+ BooleanInformationSet sparqlAsk(SPARQLQuery theQuery, QoSParameters theQoSParameters)

DeciderDecider

67


DeciderDecider



QueryTransformer

QueryTransformer



IdentifierIdentifier







SelecterSelecter



ReasonerReasoner


Plug-in RegistryPlug-in Registry



RDFStoreRDF

Store

IdentifierIdentifier Info Set Transformer

Info Set Transformer ReasonerReasoner

DeciderDecider

SelecterSelecterQueryTransformer

QueryTransformer

What does a pipeline look like?

68


LarKC Data Model :Transport By

Reference

RDF Graph

RDF Graph

RDF Graph

RDF Graph

RDF Graph

RDF Graph

Default Graph

RDF Graph

RDF Graph

RDF Graph

RDF Graph

RDF Graph

RDF Graph

RDF Graph

Dataset: Collectionof named graphs

Labeled Set: Pointers to data

Current Scale: O(1010) triples

69


LarKC Platform and the DIG plug-in

LarKC Platform

DIG InterfacePlug-in

Racer

FACT++

KAON2


Tasks of the DIG Plug-in

1. Translate a set of statements (ontology data) into a DIG data. If it is OWL-DL data, the use the OWL2DIG library to translate it into a DIG data

2. Translate SPARQL(DL) query into DIG

- deal with triple-encoded DL expressions

3. Query processing and answer checking

4. Translate DIG answers into SPARQL answers

71footer18/04/23


LarKC Platform and the DIG plug-in

LarKC Platform

DIG InterfacePlug-in

ExternalDIG Reasoner

Ontology (URI)/Set of Statements

Tell

SPARQL query

Ask

Response

SPARQL Answer


The DIG plug-in (v0.3)Have been supported • Support the DIG interface 1.1.• Support Sparqlask and Sparqlselect.• DL Expressions (conjunction, disjunction, disjoint, negation)• DIG queries (subsumption, instance, instances)Have been tested with• Racer1.7.14• PION 2.1.0To be supported soon:• Complex DL concept expressions (such as nominal, min, max,

etc.) • Complex Sparql expressions (such as Filtering, Optional, Regular

expressions, sparqlconstruct, sparqldescribe, etc.) • Complex DIG queries (role query, functional query, value pair

query)

China 2009 74

Why SPARQL-DL?

• SPARQL is too expressive for a DL reasoner can support.

• In SPARQL, there is no semantic interpretation for DL expressions such as owl:sameas, owl:disjointwith, etc.

• SPARQL-DL is a DL-specific SPARQL with some DL primitives, such as type(a, C), SubClassof(C1, C2), DisjointWith(C1,C2), ComplementOf(C1,C2),EquivalentClass(C1,C2),…(Sirin and Parsia 2007) QuickTime™ and a

decompressorare needed to see this picture.


Translation of DL expressions into RDF

triples • Using the OWL-DL method (Patel-

Schneider,Hayes, Horrocks 2004).

http://www.w3.org/TR/owl-semantics/mapping.html


SPARQL-DL Query Example 1

?- subClassOf(Wine, PotableLiquid)// to ask whether or not wine is a subclass of potable

liquid

PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>

PREFIX wine: <http://www.w3.org/TR/2003/PR-owl-guide-20031209/wine#>

PREFIX food: <http://www.w3.org/TR/2003/PR-owl-guide-20031209/food#>

ASK WHERE { wine:Wine rdfs:subClassOf

food:PotableLiquid.}



?- subClassOf(Bordeaux, and(SweetWine, TableWine))

// to ask whether or not Bordeaux is a SweetWine and TableWine


PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>

……

PREFIX owl: <http://www.w3.org/2002/07/owl#>

ASK

wine:Bordeaux rdfs:subClassOf _:x.

_:x owl:interSectionOf _:y1.

_:y1 rdf:first wine:SweetWine.

_:y1 rdf:rest wine:TableWine.

wine:Bordeaux rdf:type owl:Class.}


Simple SPARQLSelect Query: Example 3

?- subClassOf(?X, Wine)

// to list all subconcepts of Wine



SELECT ?X

WHERE { ?X rdfs:subClassOf wine:Wine.}



?- subClassOf(Bordeaux, ?X), subClassOf(?X,Wine),

subClassOf(?X,?Y).

PREFIX rdfs:http://www.w3.org/2000/01/rdf-schema#..

…..


SELECT ?X ?Y

WHERE {

wine:Bordeaux rdfs:subClassOf ?X.

?X rdfs:subClassOf wine:Wine.

?X rdfs:subClassOf ?Y.

?Y rdf:type owl:Class.}


PION and External DIG Reasoner

• PION needs an external DIG Reasoner for standard reasoning(i.e., non-inconsistency reasoning)


Compare it with that from a standard DL reasoner

• You can see that when querying an inconsistent ontology, the standard DL reasoner always returns an error message, like this:

<responses xmlns="http://dl.kr.org/dig/2003/02/lang" xmlns:xsi="http://www.w3.org/2001/XMLSchema-

instance" xsi:schemaLocation="http://dl.kr.org/dig/2003/02/lang

http://dl-web.man.ac.uk/dig/2003/02/dig.xsd"> <error

id="http://wasp.cs.vu.nl/larkc/ontology/ex#themadcow http://www.w3.org/1999/02/22-rdf-syntax-ns#type http://wasp.cs.vu.nl/larkc/ontolog/ex#vegetarian"

message="ABox http://dl.kr.org/dig/kb-1048 is incoherent."/>

</responses>


Various Strategies

• You can use the PION testbed page piontest2.htm to select different strategies for reasoning with inconsistent ontologies by PION:• selection functions (syntactic relevance,

concept syntactic relevance, or semantic relevance by Google distances),

• over-determed processing methods (first maximal consistent set, or path pruning with Google distances),

• extension strategies (linear extension or k-extension).


Questions and Discussions

Documents

China 2009 语义网与本体技术系列讲座 III 专题研究 Research Topics 黄智生 Zhisheng Huang Vrije University Amsterdam The Netherlands [email protected]