Warning:
This wiki has been archived and is now read-only.
View source for Data Range Extension: Linear Equations

← Data Range Extension: Linear Equations
Jump to: navigation, search
You do not have permission to edit this page, for the following reason:
The action you have requested is limited to users in one of the groups: Users, 106, 41712-chairs.
You can view and copy the source of this page.
__NUMBEREDHEADINGS__
{{TR|title=Data Range Extension: Linear Equations}}
<div id='editors'>
; Authors:
: [http://www.cs.man.ac.uk/~bparsia/ Bijan Parsia], University of Manchester
: [http://www.cs.man.ac.uk/~sattler/ Uli Sattler], University of Manchester
</div>
; Abstract:
: <div id='abstract'><p>{{:Shared_Abstract}}</p><p>This document specifies a syntax and semantics for incorporating linear equations with rational coefficients solved in the reals in OWL 2.</p></div>
; Status of this Document:
:This is an editors draft of a proposed extension to OWL 2 allowing for various sorts of built in and user defined binary comparison predicates. It is intended as a starting point for discussion of what might go into the main spec.
{{:Shared_Copyright}}

<div id='docbody'>

__TOC__

== Overview ==
OWL 2 has a sophisticated set of built-in numeric dataranges and [http://www.w3.org/2007/OWL/wiki/Syntax#Data_Ranges rather expressive constructors] for building new dataranges out of the basic dataranges. A major restriction on the sort of data ranges that can be built with existing constructors (i.e., datatype facets) is that only '''unary''' dataranges can be defined --- i.e.,  only datatypes may be defined. One can say that the value of a data property has to be an integer greater than 5, but one cannot say that the value of one data property is greater than that of another data property. Furthermore, one might wish to relate the values of two properties by more complex equations than mere comparisons.

This document defines an extension to OWL for defining dataranges in terms of linear (in)equalites with rational coefficients solved over the algebraic reals. These dataranges can be used in OWL axioms to, for example, define classes in terms of a constraint on the relationships between values of distinct data properties.

This extension is restricted in two respects for the sake of reasonable implementability:

* The datarange definition language is limited to linear (in)equations with rational coefficients. Transcendental functions (such as ''sin'') are not permitted. Similarly, non-linear polynomials are not permitted. While both are essential to many applications, they are not likely to be widely implemented due to practical and theoretical problems that still must be dealt with.
* Equation-based dataranges can only constrain values of data properties of a single individual. That is, one cannot compare the boiling point of the one individual, ''water'', with the boiling point of another individual, say, ''copper''. Restrictions using dataranges this way are known as '''path free'''. While the theory for arbitrary data restrictions is well known, there is still a dearth of optimizations that would make their inclusion practical.

These restrictions may be lifted, to various degrees,  in future versions of this specification.

== Examples ==

Consider the relation between the boiling point and the melting point of a substance. For example, for water (at 1 atmosphere) the boiling point is 100C and the melting point 0C. This can be represented in plain OWL quite easily:
 ClassAssertion(DataHasValue(melting_point "0"^^xsd:decimal) water)
 ClassAssertion(DataHasValue(boiling_point "100"^^xsd:decimal) water)

From these assertions it follows that the boiling point of water is greater than its melting point. This is, in fact, a general principle for substances: the boiling point of a normal physical substance is greater or equal to its melting point. This physical law can be expressed with a datarange with two free variables x and y, representing the melting and boiling point, respectively.:
 EquivalentClasses(NormalSubstance DataAllValuesFrom(melting_point boiling_point 
         DataComparison(Arguments(x y) leq( x y ))))

With this definition (and given that ''melting_point'' and ''boiling_point'' are functional), one can infer:
 ClassAssertion(NormalSubstance water)

When administering drugs, there are many factors that go into determining the maximum safe dose. Often, the maximum the maximum single dose of a drug is computed in terms of milligram of drug per kilogram of body weight.

 EquivalentClasses(SafelyDosedPatient DataAllValuesFrom(tookDrugInAmount weight
         DataComparison(Arguments(totalDoseInMg weightinKg) leq(totalDoseInMg times(2, weightInKg)))))

This axiom states that the safe dose is 2 milligrams per kilogram, and thus that a safe dose (in milligrams) for a person of a given weight must be less than 2 times the weight (in kilograms) of the patient. 

As safe doses vary with age and other factors, one could define a number of such classes with varying constraints on the safety of the dose.

==Syntax==
=== Functional Syntax ===

As with built-in OWL 2 data ranges, linear (in)equations may be used to form universal, existential, and quantified restrictions on (sets of) data properties.

<div class="grammar">
<span class="nonterminal">ComparisonRelation</span> := <br/>
&nbsp;&nbsp;&nbsp; 'gt' |<br />
&nbsp;&nbsp;&nbsp; 'lt' | <br />
&nbsp;&nbsp;&nbsp; 'geq' |<br />
&nbsp;&nbsp;&nbsp; 'leq' |<br />
&nbsp;&nbsp;&nbsp; 'eq' |<br />
&nbsp;&nbsp;&nbsp; 'neq' <br/>
<span class="nonterminal">Variable</span> := <span class="nonterminal">NCName</span><br />
<span class="nonterminal">Rational</span> := Integer / NonZeroInteger <br />
<span class="nonterminal">Term</span> := 'times' '(' [ <span class="nonterminal">Rational</span> ] <span class="nonterminal">Variable</span>  ')' | <span class="nonterminal">Variable</span><br/>
<span class="nonterminal">LinearExpression</span>:= 'plus' '(' <span class="nonterminal">Term</span> { <span class="nonterminal">Term</span> }  ')' | <span class="nonterminal">Term</span> | <span class="nonterminal">Variable</span><br/>
<span class="nonterminal">Arguments</span> := 'Arguments' '(' <span class="nonterminal">NCName</span> { <span class="nonterminal">NCName</span> } ')'<br/>
<span class="nonterminal">Comparison</span> := 'DataComparison' '('  <span class="nonterminal">Arguments</span> <span class="nonterminal">ComparisonRelation</span>'(' <span class="nonterminal">Variable</span> <span class="nonterminal">Variable</span> ')' ')'<br />
<span class="nonterminal">ScaledComparison</span> :=  'DataComparison' (' <span class="nonterminal">Arguments</span> <span class="nonterminal">ComparisonRelation</span> '(' <span class="nonterminal">Term</span> <span class="nonterminal">Term</span> ')' ')'<br />
<span class="nonterminal">LinearComparison</span> := 'DataComparison' '('   <span class="nonterminal">Arguments</span> <span class="nonterminal">ComparisonRelation</span> '(' <span class="nonterminal">LinearExpression</span> <span class="nonterminal">LinearExpression</span> ')' ')'<br />
<span class="nonterminal">DataComparison</span> := <span class="nonterminal">Comparison</span> | <span class="nonterminal">ScaledComparison</span> | <span class="nonterminal">LinearComparison</span>
</div>

The definition of a DataRange is extended with the various comparisons:
<div class="grammar">
<span class="nonterminal">DataRange</span> :=<br />
&nbsp;&nbsp;&nbsp; <span class="nonterminal">Datatype</span> |<br />
&nbsp;&nbsp;&nbsp; <span class="nonterminal">DataComplementOf</span> |<br />
&nbsp;&nbsp;&nbsp; <span class="nonterminal">DataOneOf</span> |<br />
&nbsp;&nbsp;&nbsp; <span class="nonterminal">DatatypeRestriction</span> |<br />
&nbsp;&nbsp;&nbsp; <span class="nonterminal">DataComparison</span>
</div>

It is not currently possible for user defined (in)equations to be named, though it is easy to spec a natural syntax:

 <div class="grammar"> <span class="nonterminal">DataComparisonDefinition</span> := 'DataComparisonDefinition' '(' axiomAnnotations IRI DataRange ')' </div>

In order to retain decidability with naming, there needs to be acyclicity condition akin to [http://www.w3.org/2007/OWL/wiki/Syntax#The_Restrictions_on_the_Axiom_Closure those for datatypes]. Furthermore, since there are ''DataComparisons'' which are equivalent to datatypes, the datatype and data comparison conditions must appropriately interact.

=== RDF Mapping ===
(In)equations in RDF are expressed using MathML as below. The equations are serialized as ''rdf:XMLLiteral''s. The content of those literals must conform to the "owl-linear-comparisons-mathml.xsd".

<pre>
<!DOCTYPE rdf:RDF [
<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" >
]>
<rdf:RDF xmlns="http://example.org/#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:owl="http://www.w3.org/2002/07/owl#">
    <owl:Ontology rdf:about="http://example.org/"/>
    <owl:DatatypeProperty rdf:about="#boiling_point"/>
    <owl:DatatypeProperty rdf:about="#melting_point"/>

    <owl:Class rdf:about="#NormalSubstance">
        <owl:equivalentClass>
            <owl:Restriction>
                <owl:onProperties rdf:parseType="Collection">
                    <owl:DatatypeProperty rdf:about="#boiling_point"/>
                    <owl:DatatypeProperty rdf:about="#melting_point"/>
                </owl:onProperties>
                <owl:allValuesFrom>
                    <owl:DataComparison>
                        <rdf:value rdf:parseType="Literal">
                            <lambda xmlns="http://www.w3.org/1998/Math/MathML"
                                xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                                xsi:schemaLocation="http://www.w3.org/1998/Math/MathML
                                            owl-linear-comparisons-mathml.xsd">
                                <bvar>
                                    <ci>x</ci>
                                </bvar>
                                <bvar>
                                    <ci>y</ci>
                                </bvar>
                                <apply>
                                    <leq/>
                                    <ci>x</ci>
                                    <ci>y</ci>
                                </apply>
                            </lambda>
                        </rdf:value>
                    </owl:DataComparison>
                </owl:allValuesFrom>
            </owl:Restriction>
        </owl:equivalentClass>
    </owl:Class>

    <rdf:Description rdf:about="#water">
        <rdf:type>
            <owl:Restriction>
                <owl:onProperty rdf:resource="#boiling_point"/>
                <owl:hasValue rdf:datatype="&xsd;integer">100</owl:hasValue>
            </owl:Restriction>
        </rdf:type>
        <rdf:type>
            <owl:Restriction>
                <owl:onProperty rdf:resource="#melting_point"/>
                <owl:hasValue rdf:datatype="&xsd;integer">0</owl:hasValue>
            </owl:Restriction>
        </rdf:type>
    </rdf:Description>
 </rdf:RDF>
</pre>

===XML Syntax===

For the XML syntax, the terminals of the functional syntax are mapped into corresponding MathML elements. Consider the water example:
<pre>
<Ontology xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.w3.org/2002/07/owl# owlxml-datarange.xsd"
    xmlns="http://www.w3.org/2002/07/owl#"
    ontologyIRI="http://example.org/">
    <ClassAssertion>
        <DataHasValue>
            <DataProperty IRI="melting_point"/>
            <Literal datatypeIRI="xsd:decimal">0</Literal>
        </DataHasValue>
        <NamedIndividual IRI="water"/>
    </ClassAssertion>
    <ClassAssertion>
        <DataHasValue>
            <DataProperty IRI="boiling_point"/>
            <Literal datatypeIRI="xsd:decimal">100</Literal>
        </DataHasValue>
        <NamedIndividual IRI="water"/>
    </ClassAssertion>
    
    <EquivalentClasses>
        <Class IRI="NormalSubstance"/>
        <DataAllValuesFrom>
            <DataProperty IRI="melting_point"/>
            <DataProperty IRI="boiling_point"/>
            <DataComparison>
                <lambda xmlns="http://www.w3.org/1998/Math/MathML">
                    <bvar>
                        <ci>x</ci>
                    </bvar>
                    <bvar>
                        <ci>y</ci>
                    </bvar>
                    <apply>
                        <leq/>
                        <ci>x</ci>
                        <ci>y</ci>
                    </apply>
                </lambda>
            </DataComparison>
        </DataAllValuesFrom>
    </EquivalentClasses>
</Ontology>
</pre>

In order to validate, one must use an extended version of the XML Schema. See Appendix A for the schema.



== Semantics ==
The semantics of all constructs where data ranges can occur (DataSomeValuesFrom, DataAllValuesFrom, DataMinCardinality, DataExactCardinality, DataMaxCardinality, DataComplementOf) is defined in Section 2 of the [http://www.w3.org/TR/2008/WD-owl2-semantics-20080411/#Model-Theoretic_Semantics_for_OWL_2 Semantics]. This section defines the meaning of  DataComparisons.

As explained in the [http://www.w3.org/TR/2008/WD-owl2-semantics-20080411/#Model-Theoretic_Semantics_for_OWL_2 Semantics] document, this is accomplished by extending the  datatype interpretation function ''&sdot;&nbsp;<sup>DT</sup>'' to ''DataComparison''. First some notation: for an expression ''exp'', a variable ''y'' and a value ''v'', ''exp[y -> v]'' is the expression obtained by replacing all occurrences of ''y'' in ''exp'' with ''v''. 

Next, on the value space of ''owl:real'', the equality ''='' and  ordering ''<'' are  defined as usual, and  the operators ''+'' and ''*'' are the usual addition and multiplication operators on the real numbers.

The value of terms is then defined as follows: 
* ''(times(v1 v2))<sup>DT</sup> = v1 * v2''
* ''(plus (t1 ... tk))<sup>DT</sup> = (t1)<sup>DT</sup> + ... + (tk)<sup>DT</sup>''


Intuitively, in order to find out whether a pair ''(5,60)'' of numbers is in, say, ''DataComparison(Arguments(y1 y2) lt (times("4"^^owl:real y1) times("1"^^owl:real y1)))<sup>DT</sup>'', one replaces all occurrences of ''y1'' in both ''times(...)'' terms with ''5'', all occurrences of ''y2'' in both terms  with ''60'', computes the value of both ''times(...)'' terms (the first giving 20, the second giving 60), and then checks whether ''lt'' holds between them. Since this is indeed the case, the pair ''(5,60)'' is in ''DataComparison(...)''. 

In what follows, ''y1'' and ''y2'' refer to variables, ''t1'' and ''t2'' to terms, and ''L1'' and ''L2'' to linear expressions.

* ''(DataComparison(Arguments(y1 y2) comprel(y1 y2)))<sup>DT</sup> = ''
** ''{ (v1, v2) in ((owl:real)<sup>DT</sup>)<sup>2</sup> | v1 < v2 }'' if ''comprel'' is ''lt''
** ''{ (v1, v2) in ((owl:real)<sup>DT</sup>)<sup>2</sup> | v2 < v1 }'' if ''comprel'' is ''gt''
** ''{ (v1, v2) in ((owl:real)<sup>DT</sup>)<sup>2</sup> | v1 < v2'' or ''v1 = v2 }'' if ''comprel'' is ''leq''
** ''{ (v1, v2) in ((owl:real)<sup>DT</sup>)<sup>2</sup> | v2 < v1'' or ''v1 = v2 }'' if ''comprel'' is ''geq''
** ''{ (v1, v2) in ((owl:real)<sup>DT</sup>)<sup>2</sup> | v2 = v1 }'' if ''comprel'' is ''eq''
** ''{ (v1, v2) in ((owl:real)<sup>DT</sup>)<sup>2</sup> | v2 < v1''  or ''v1 < v2 }'' if ''comprel'' is ''neq''


* ''(DataComparison(Arguments(y1 y2) comprel(t1 t2)))<sup>DT</sup>  = ''
** ''{ (v1, v2) in ((owl:real)<sup>DT</sup>)<sup>2</sup> | (t1[y1->v1][y2->v2])<sup>DT</sup> < (t2[y1->v1][y2->v2])<sup>DT</sup> }'' if ''comprel'' is ''lt''
** ''{ (v1, v2) in ((owl:real)<sup>DT</sup>)<sup>2</sup> | (t2[y1->v1][y2->v2]))<sup>DT</sup> < (t1[y1->v1][y2->v2])<sup>DT</sup> }'' if ''comprel'' is ''gt''
** ''{ (v1, v2) in ((owl:real)<sup>DT</sup>)<sup>2</sup> | (t1[y1->v1][y2->v2]))<sup>DT</sup> < (t2[y1->v1][y2->v2])<sup>DT</sup>'' or ''(t1[y1->v1][y2->v2])<sup>DT</sup> = (t2[y1->v1][y2->v2])<sup>DT</sup> }'' if ''comprel'' is ''leq''
** ''{ (v1, v2) in ((owl:real)<sup>DT</sup>)<sup>2</sup> | (t2[y1->v1][y2->v2]))<sup>DT</sup> < (t1[y1->v1][y2->v2])<sup>DT</sup>'' or ''(t1[y1->v1][y2->v2])<sup>DT</sup> = (t2[y1->v1][y2->v2])<sup>DT</sup> }'' if ''comprel'' is ''geq''
** ''{ (v1, v2) in ((owl:real)<sup>DT</sup>)<sup>2</sup> | (t2[y1->v1][y2->v2]))<sup>DT</sup> = (t1[y1->v1][y2->v2])<sup>DT</sup> }'' if ''comprel'' is ''eq''
** ''{ (v1, v2) in ((owl:real)<sup>DT</sup>)<sup>2</sup> | (t2[y1->v1][y2->v2]))<sup>DT</sup> < (t1[y1->v1][y2->v2])<sup>DT</sup>''  or ''(t1[y1->v1][y2->v2])<sup>DT</sup> < (t2[y1->v1][y2->v2])<sup>DT</sup> }'' if ''comprel'' is ''neq''


* ''(DataComparison(Arguments(y1 ... yk) comprel(L1 L2)))<sup>DT</sup> = ''
** ''{ (v1,..., vk) in ((owl:real)<sup>DT</sup>)<sup>k</sup> | (L1[y1->v1]...[yk->vk])<sup>DT</sup> < (L2[y1->v1]...[yk->vk])<sup>DT</sup> }'' if ''comprel'' is ''lt''
** ''{ (v1, ...,vk) in ((owl:real)<sup>DT</sup>)<sup>k</sup> | (L2[y1->v1]...[yk->vk])<sup>DT</sup> < (L1[y1->v1]...[yk->vk])<sup>DT</sup> }'' if ''comprel'' is ''gt''
** ''{ (v1,..., vk) in ((owl:real)<sup>DT</sup>)<sup>k</sup> | (L1[y1->v1]...[yk->vk])<sup>DT</sup> < (L2[y1->v1]...[yk->vk])<sup>DT</sup>'' or ''(L1[y1->v1]...[yk->vk])<sup>DT</sup> = (L2[y1->v1]...[yk->vk])<sup>DT</sup> }'' if ''comprel'' is ''leq''
** ''{ (v1,...,vk) in ((owl:real)<sup>DT</sup>)<sup>k</sup> | (L2[y1->v1]...[yk->vk])<sup>DT</sup> < (L1[y1->v1]...[yk->vk])<sup>DT</sup>'' or ''(L1[y1->v1]...[yk->vk])<sup>DT</sup> = (L2[y1->v1]...[yk->vk])<sup>DT</sup> }'' if ''comprel'' is ''geq''
** ''{ (v1,..., vk) in ((owl:real)<sup>DT</sup>)<sup>k</sup> | (L2[y1->v1]...[yk->vk])<sup>DT</sup> = (L1[y1->v1]...[yk->vk])<sup>DT</sup> }'' if ''comprel'' is ''eq''
** ''{ (v1,..., vk) in ((owl:real)<sup>DT</sup>)<sup>k</sup> | (L2[y1->v1]...[yk->vk])<sup>DT</sup> < (L1[y1->v1]...[yk->vk])<sup>DT</sup>''  or ''(L1[y1->v1]...[yk->vk])<sup>DT</sup> < (L2[y1->v1]...[yk->vk])<sup>DT</sup> }'' if ''comprel'' is ''neq''

== Implementation Considerations ==
There is a rich literature on implementing linear solvers. The key papers for the integration between OWL and a linear solver are:
* [http://SunSITE.Informatik.RWTH-Aachen.de/Publications/CEUR-WS//Vol-86/13-Lutz.ps Description Logics with Concrete Domains - A Survey]
* [http://www.racer-systems.com/technology/contributions/2003/HaMo03b.pdf Description Logic Systems with Concrete Domains: Applications for the Semantic Web]

== Appendix: XML Schemas ==
This schema is named "owlxml-with-linear-comparisons.xsd".
<pre>
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    targetNamespace="http://www.w3.org/2002/07/owl#" xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:m="http://www.w3.org/1998/Math/MathML">
    <xsd:import namespace="http://www.w3.org/1998/Math/MathML"
        schemaLocation="owl-comparisons-mathml.xsd"/>
    <xsd:redefine schemaLocation="http://www.w3.org/2009/09/owl2-xml.xsd">
        <xsd:group name="DataRange">
            <xsd:choice>
                <xsd:group ref="owl:DataRange"/>
                <xsd:element ref="owl:DataComparison"/>
            </xsd:choice>
        </xsd:group>
    </xsd:redefine>

    <xsd:complexType name="DataComparison">
        <xsd:complexContent>
            <xsd:extension base="owl:DataRange">
                <xsd:sequence>
                    <xsd:element ref="m:lambda" minOccurs="1" maxOccurs="1"/>
                </xsd:sequence>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>
    <xsd:element name="DataComparison" type="owl:DataComparison"/>
</xsd:schema>
</pre>

This schema is named "owl-linear-comparisons-mathml.xsd".
<pre>
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    targetNamespace="http://www.w3.org/1998/Math/MathML" xmlns="http://www.w3.org/1998/Math/MathML"
    xmlns:m="http://www.w3.org/1998/Math/MathML" elementFormDefault="qualified">
    <xsd:element name="gt"/>
    <xsd:element name="lt"/>
    <xsd:element name="geq"/>
    <xsd:element name="leq"/>
    <xsd:element name="eq"/>
    <xsd:element name="neq"/>
    
    <xsd:element name="ci" type="xsd:NCName"/>
    <xsd:element name="sep"/>
    <xsd:element name="cn">
        <xsd:complexType mixed="true">
            <xsd:sequence>
                <xsd:element ref="sep" maxOccurs="1"/>
            </xsd:sequence>
            <xsd:attribute name="type">
                <xsd:simpleType>
                    <xsd:restriction base="xsd:string">
                        <xsd:pattern value="real|rational"/>
                    </xsd:restriction>
                </xsd:simpleType>
            </xsd:attribute>
        </xsd:complexType>
    </xsd:element>

    <xsd:element name="bvar">
        <xsd:complexType>
            <xsd:sequence>
                <xsd:element ref="m:ci" minOccurs="1" maxOccurs="1"/>
            </xsd:sequence>
        </xsd:complexType>
    </xsd:element>
    <xsd:element name="times">
        <xsd:complexType>
            <xsd:sequence>
                <xsd:element ref="m:cn"/>
                <xsd:element ref="m:ci" maxOccurs="1" minOccurs="1"/>
            </xsd:sequence>
        </xsd:complexType>
    </xsd:element>
    
    <xsd:element name="plus">
        <xsd:complexType>
            <xsd:sequence>
                <xsd:element ref="m:times" minOccurs="1"/>
            </xsd:sequence>
        </xsd:complexType>
    </xsd:element>
    
    <xsd:element name="apply">
        <xsd:complexType>
            <xsd:sequence>
                <xsd:choice minOccurs="1" maxOccurs="1">
                    <xsd:element ref="m:gt"/>
                    <xsd:element ref="m:lt"/>
                    <xsd:element ref="m:geq"/>
                    <xsd:element ref="m:leq"/>
                    <xsd:element ref="m:eq"/>
                    <xsd:element ref="m:neq"/>
                </xsd:choice>
                <xsd:choice minOccurs="2" maxOccurs="2">
                    <xsd:element ref="m:ci"/>
                    <xsd:element ref="m:times"/>
                    <xsd:element ref="m:plus"/>
                </xsd:choice>
            </xsd:sequence>
        </xsd:complexType>
    </xsd:element>

    <xsd:element name="lambda">
        <xsd:complexType>
            <xsd:sequence>
                <xsd:element ref="m:bvar" minOccurs="1" maxOccurs="unbounded"/>
                <xsd:element ref="m:apply"/>
            </xsd:sequence>
        </xsd:complexType>
    </xsd:element>
</xsd:schema>
</pre>

<div id="changelog">
== Appendix: Change Log (Informative) ==

=== Changes Since Working Group Note ===

This section summarizes the changes to this document since the [http://www.w3.org/TR/2009/NOTE-owl2-manchester-syntax-20091027/ Working Group Note of 27 October, 2009].

*With the publication of the XML Schema Definition Language (XSD) 1.1 Part 2: Datatypes [http://www.w3.org/TR/2012/REC-xmlschema11-2-20120405/ Recommendation of 5 April 2012], the elements of OWL 2 which are based on XSD 1.1 are now considered required, and the note detailing the optional dependency on the XSD 1.1 [http://www.w3.org/TR/2009/CR-xmlschema11-2-20090430/ Candidate Recommendation of 30 April, 2009] has been removed from the "Status of this Document" section.

=== Changes Since Draft of 11 June 2009 ===

* Slight change to the functional syntax grammar (which doesn't change the recognized language).
* Added XML Schemas for the expression language and for an extenion to the XML Serialization.
* Removed naming of (in)equations.
* Removed Manchester syntax.
</div>
 
</div>
Templates used on this page:
Return to Data Range Extension: Linear Equations.
Retrieved from "https://www.w3.org/2007/OWL/wiki/Data_Range_Extension:_Linear_Equations"
View source for Data Range Extension: Linear Equations

Navigation menu

Personal tools

Namespaces

Variants

Views

More

OWL Working Group

Tools
