<!--++ I4.5/conclusions001.rdf ** generated using webont test editor. ++-->
<!--++ Created 23 Jul 2003 11:07:30 GMT ++-->
<!--
  Copyright World Wide Web Consortium, (Massachusetts Institute of
  Technology, European Research Consortium for Informatics and
  Mathematics, Keio University).

  All Rights Reserved.

  Please see the full Copyright clause at
  <http://www.w3.org/Consortium/Legal/copyright-software.html>

  $Id: conclusions001.rdf,v 1.5 2003-12-05 05:09:34 jeremy_carroll Exp $
-->
<!--
An example combinging owl:oneOf and owl:inverseOf.
-->
<!-- Author: Charles White -->
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:first="http://www.w3.org/2002/03owlt/I4.5/premises001#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xml:base="http://www.w3.org/2002/03owlt/I4.5/conclusions001" >

  <first:EuroMP rdf:about="premises001#Kinnock" />
  <owl:Class rdf:about="premises001#EuroMP"/>

</rdf:RDF>
