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.
The proposed rules are 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 } ')'
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.
atom ::= description '(' i-object ')'
| individualvaluedPropertyID '(' i-object i-object ')'
| datavaluedPropertyID '(' i-object d-object ')'
| sameAs '(' i-object i-object ')'
| differentFrom '(' i-object i-object ')'
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>.
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.
Lot of XML encodings could be imagined, but the most obvious solution is to extend the existing OWL Web Ontology Language XML Presentation Syntax [OWL XML], which can be straightforwardly modified to deal with OWL Rules. This has several advantages:
arbitrary OWL classes can be used as predicates in rules;
rules and ontology axioms can be freely mixed;
the existing XSLT stylesheet can easily be extended to provide a mapping to RDF graphs that extends the OWL RDF/XML exchange syntax.
Below are more details:
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>
where name - refers to a name of this ontology, which is the base URI of this element.
After it we 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>
where name - a reference to a name of this variable
and
<Rule>
Content: ( Annotation*, antecedent, consequent )
</Rule>
where
<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)
Abstract OWL:
Combination of the 'hasParent' and 'hasBrother' properties implies the 'hasUncle property:
Generic rule syntax:
hasParent(?x1,?x2) ∧ hasBrother(?x2,?x3) ⇒ hasUncle(?x1,?x3)
Abstract OWL syntax:
Implies(Antecedent(hasParent(I-variable(x1) I-variable(x2))
hasBrother(I-variable(x2) I-variable(x3)))
Consequent(hasUncle(I-variable(x1) I-variable(x3))))
Assert that art objects inherit the style/period of the artist that created them:
Generic rule syntax:
Artist(?x) & artistStyle(?x,?y) & Style(?y) & creator(?z,?x) ⇒ style/period(?z,?y)
Abstract OWL syntax:
Implies(Antecedent(Artist(I-variable(x))
artistStyle(I-variable(x) I-variable(y))
Style(I-variable(y))
creator(I-variable(z) I-variable(x)))
Consequent(style/period(I-variable(z) I-variable(y))))
XML Concrete Syntax:
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>
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.