To jest stara wersja strony!


Opis

Wojciech Franczak, email: franczak@student.agh.edu.pl

OWL_Rules

How decision rules can be represented, encoded in OWL rules in description logic, description logic programs, swrl?

Spotkania

20090409

20090319

20090305

  • skupiamy się na swrl, szkic biblio w tex , przyklad

20090219

Projekt

Sprawozdanie

OWL

The Web Ontology Language OWL extends RDF and RDFS. It is primary aim is to bring the expressive and reasoning power of description logic to the semantic web. Unfortunately, not everything from RDF can be expressed in DL. For example, the classes of classes are not permitted in the (chosen) DL, and some of the triple expressions would have no sense in DL. That is why OWL can be only syntactic extension of RDF/RDFS (note that RDFS is both syntactic and semantic extension of RDF). To partially overcome this problem, and also to allow layering within OWL, three species of OWL are defined.

OWL Lite can be used to express taxonomy and simple constraints, such as 0 and 1 cardinality. It is the simplest OWL language and corresponds to description logic SHIF. OWL DL supports maximum expressiveness while retaining computational completeness and decidability. The DL in the name shows that it is intended to support description logic capabilities. OWL DL corresponds to description logic SHOIN. OWL Full has no expressiveness constraints, but also does not guarantee any computational properties. It is formed by the full OWL vocabulary, but does not no impose any syntactic constrains, so that the full syntactic freedom of RDF can be used.

These three languages are layered in a sense that every legal OWL Lite ontology is a legal OWL DL ontology, every legal OWL DL ontology is a legal OWL Full ontology, every valid OWL Lite conclusion is a valid OWL DL conclusion, and every valid OWL DL conclusion a valid OWL Full conclusion. The inverses of these relations generally do not hold. Also, every OWL ontology is a valid RDF document (i.e., DL expressions are mapped to triples), but not all RDF documents are valid OWL Lite or OWL DL documents. In this thesis, we are interested primarily in OWL DL. If we will not indicate otherwise, we mean OWL DL by OWL in the rest of the text.

According to the page: http://www.cs.man.ac.uk/~horrocks/DAML/Rules/#2.1, we will be able to say more about OWL construction, rules, ontologies, also we will be able to prepare easy examples of OWL use.

The proposed rules are of the form of an implication between an antecedent (body) and consequent (head). The intended meaning can be read as: whenever the conditions specified in the antecedent hold, then the conditions specified in the consequent must also hold.

Both the antecedent (body) and consequent (head) consist of zero or more atoms. An empty antecedent is treated as trivially true (i.e. satisfied by every interpretation), so the consequent must also be satisfied by every interpretation; an empty consequent is treated as trivially false (i.e., not satisfied by any interpretation), so the antecedent must also not be satisfied by any interpretation. Multiple atoms are treated as a conjunction.

An OWL ontology in the abstract syntax contains a sequence of axioms and facts. Axioms may be of various kinds, e.g., subClass axioms and equivalentClass axioms. It is proposed to extend this with rule axioms.

axiom ::= rule 

A rule axiom consists of an antecedent (body) and a consequent (head), each of which consists of a (posibly empty) set of atoms.

rule ::= 'Implies(' { annotation } antecedent consequent ')'
antecedent ::= 'Antecedent(' { atom } ')'
consequent ::= 'Consequent(' { atom } ')'
atom ::= description '(' i-object ')'
 | individualvaluedPropertyID '(' i-object i-object ')'
 | datavaluedPropertyID '(' i-object d-object ')'
 | sameAs '(' i-object i-object ')'
 | differentFrom '(' i-object i-object ')'

Atoms can be of the form C(x), P(x,y), sameAs(x,y) or differentFrom(x,y), where C is an OWL description, P is an OWL property, and x,y are either variables, OWL individuals or OWL data values. In the context of OWL Lite, descriptions in atoms of the form C(x) may be restricted to class names.

The basic idea for Direct Model Theoretic Semantics is that we need to define bindings, extensions of OWL interpretations that also map variables to elements of the domain. The rule come true by an interpretation if every binding that satisfies the antecedent also satisfies the consequent. The semantic conditions relating to axioms and ontologies are unchanged, e.g., an interpretation satisfies an ontology iff it satisfies every axiom (including rules) and fact in the ontology.

Given an abstract OWL interpretation I, a binding B(I) is an abstract OWL interpretation that extends I such that function S maps i-variables to elements of R and d-variables to elements of LVT respectively. We recall that an Abstract OWL interpretation is a tuple of the form: I = <R, V, EC, ER, S>.

Heading 1 Heading 2
Row 1 Col 1 Row 1 Col 2
Row 2 Col 1 Row 2 Col 2

Atom Condition on Interpretation description(x) S(x) ∈ EC(description) property(x,y) <S(x),S(y)> ∈ ER(property) sameAs(x,y) S(x) = S(y) differentFrom(x,y) S(x) ≠ S(y)

binding B(I) satisfies an antecedent A iff A is empty or B(I) satisfies every atom in A. A binding B(I) satisfies a consequent C iff C is not empty and B(I) satisfies every atom in C. A rule is satisfied by an interpretation I iff for every binding B such that B(I) satisfies the antecedent, B(I) also satisfies the consequent.

The semantic conditions relating to axioms and ontologies are unchanged. In particular, an interpretation satisfies an ontology iff it satisfies every axiom (including rules) and fact in the ontology; an ontology is consistent iff it is satisfied by at least one interpretation; an ontology O2 is entailed by an ontology O1 iff every interpretation that satisfies O1 also satisfies O2.

Most important elements for OWL - XML: Ontology, Variable, Rule

In the first place, the ontology root element is extended to include „Rule” and „Variable” axioms.

<Ontology
name = xsd:anyURI 
>
Content: (VersionInfo | PriorVersion | BackwardCompatibleWith | 
          IncompatibleWith | Imports | Annotation | 
          Class[axiom] | EnumeratedClass(D,F) | 
          SubClassOf(D,F) | EquivalentClasses | DisjointClasses(D,F) | 
          DatatypeProperty | ObjectProperty | 
          SubPropertyOf | EquivalentProperties | 
          Individual[axiom] | SameIndividual | DifferentIndividuals |
          Rule[axiom] | Variable[axiom])* 
</Ontology>

name - refers to a name of this ontology, which is the base URI of this element.

We then simply need to add the relevant syntax for variables and rules.

Variable axioms are statements about variables, indicating that the given URI is to be used as a variable, and adding any annotations.

<Variable
name = xsd:anyURI
>
Content: ( Annotation* ) 
</Variable>

name - a reference to a name of this variable

<Rule>
Content: ( Annotation*, antecedent, consequent )
</Rule>
<antecedent>
Content: ( atom* )
</antecedent>
<consequent>
Content: ( atom* )
</consequent>

Atoms can be formed from unary predicates (classes), binary predicates (properties), equalities or inequalities.

Content: (classAtom | individualPropertyAtom | datavaluedPropertyAtom | 
          sameIndividualAtom | differentIndividualsAtom)

An example:

The following example is due to Guus Schreiber, and is based on ontologies used in an image annotation demo.

The rule expresses the fact that, given knowledge about the AAT style of certain ULAN artists (e.g., van Gogh is an Impressionist painter), we can derive the style of an art object (represented with the VRA element „style/period”) from the value of the creator of the art object (represented by the VRA element „creator”, a subproperty of dc:creator):

<owlx:Rule> 
<owlx:antecedent> 
  <owlx:classAtom> 
    <owlx:class="&ulan;Artist" />
    <owlx:Variable owlx:name="_x" />
  </owlx:classAtom> 
  <owlx:classAtom> 
    <owlx:class="&aat;Style" />
    <owlx:Variable owlx:name="_y" />
  </owlx:classAtom> 
  <owlx:individualPropertyAtom  owlx:property="&aatulan;artistStyle"> 
    <owlx:Variable owlx:name="_x" />
    <owlx:Variable owlx:name="_y" />
  </owlx:individualPropertyAtom> 
  <owlx:individualPropertyAtom  owlx:property="&vra;creator"> 
    <owlx:Variable owlx:name="_x" />
    <owlx:Variable owlx:name="_z" />
  </owlx:individualPropertyAtom> 
</owlx:antecedent> 
<owlx:consequent> 
  <owlx:individualPropertyAtom  owlx:property="&vra;style/period"> 
    <owlx:Variable owlx:name="_z" />
    <owlx:Variable owlx:name="_y" />
  </owlx:individualPropertyAtom> 
</owlx:consequent> 
</owlx:Rule>

More examples

Class Inferences

Cat Owners like Cats

Class(a:cat_owner complete intersectionOf(a:person
restriction(a:has_pet someValuesFrom (a:cat))))
SubPropertyOf(a:has_pet a:likes)
Class(a:cat_liker complete intersectionOf(a:person
restriction(a:likes someValuesFrom (a:cat))))

Drivers are Grown Ups (Note: A grown up is an adult person)

Class(a:driver complete intersectionOf(a:person
restriction(a:drives someValuesFrom (a:vehicle))))
Class(a:driver partial a:adult)
Class(a:grownup complete intersectionOf(a:adult a:person))

Giraffes are Vegetarians

Class(a:giraffe partial a:animal
restriction(a:eats allValuesFrom (a:leaf)))
Class(a:leaf partial restriction(a:part_of someValuesFrom (a:tree)))
Class(a:tree partial a:plant)
DisjointClasses(unionOf(restriction(a:part_of someValuesFrom (a:animal)) a:animal) 
                        unionOf(a:plant restriction(a:part_of someValuesFrom (a:plant))))
Class(a:vegetarian complete intersectionOf(
  restriction(a:eats allValuesFrom (complementOf(restriction(a:part_of someValuesFrom (a:animal))))) 
  restriction(a:eats allValuesFrom (complementOf(a:animal))) a:animal))
  • Giraffes only eat leaves
  • Leaves are parts of trees, which are plants
  • Plants and parts of plants are disjoint from animals and parts of animals
Instance Inferences

The Daily Mirror is a Tabloid

Individual(a:Daily_Mirror type(owl:Thing))
Individual(a:Mick type(a:male)
value(a:drives a:Q123_ABC)
value(a:reads a:Daily_Mirror))
Individual(a:Q123_ABC type(a:van) type(a:white_thing))
Class(a:white_van_man complete 
intersectionOf(a:man restriction(a:drives someValuesFrom (intersectionOf(a:van a:white_thing)))))
Class(a:white_van_man partial restriction(a:reads allValuesFrom (a:tabloid)))

Tom is a Cat

Individual(a:Minnie type(a:female) type(a:elderly) value(a:has_pet a:Tom))
Individual(a:Tom type(owl:Thing))
ObjectProperty(a:has_pet domain(a:person) range(a:animal))
Class(a:old_lady complete 
intersectionOf(a:person a:female a:elderly))
Class(a:old_lady partial intersectionOf(
restriction(a:has_pet allValuesFrom (a:cat)) 
restriction(a:has_pet someValuesFrom (a:animal))

BIBTEX

Is a tool for formatting lists of references. The BibTeX tool is typically used together with the LaTeX document preparation system.

code example:

@Book{abramowitz+stegun,
  author =    "Milton Abramowitz and Irene A. Stegun",
  title =     "Handbook of Mathematical Functions with
               Formulas, Graphs, and Mathematical Tables",
  publisher = "Dover",
  year =      1964,
  address =   "New York",
  edition =   "ninth Dover printing, tenth GPO printing"
  }

Inclusion bibliography base in the file follow by after command 'bibliography'

example:

\bibliography{file_name} - where 'file_name' is file with base.

Prezentacja

Materiały

pl/miw/2009/miw09_owl_rules_1.1242068808.txt.gz · ostatnio zmienione: 2019/06/27 15:57 (edycja zewnętrzna)
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0