W3C home > Mailing lists > Public > public-rif-wg@w3.org > January 2007

Re: [RIFRAF] ho to proceed? Part I: Ontologization

From: Leora Morgenstern <leora@us.ibm.com>
Date: Tue, 23 Jan 2007 11:20:05 -0500
To: axel@polleres.net
Cc: W3C RIF WG <public-rif-wg@w3.org>, public-rif-wg-request@w3.org
Message-ID: <OFF380EA5D.59FDB3C1-ON8525726C.00571586-8525726C.0059B829@us.ibm.com>
Axel,

I agree that to a certain extent the construction of the RIFRAF ontology 
depends on finalizing the core.
I think that an equally important prerequisite --- and one that we ought 
to be doing now ---- is going through the list of RIFRAF discriminators 
and seeing if we can clear it up and flesh it out as much as possible.

Let me give two examples of the sort of clean-up/fleshing-out that I 
believe is necessary.

(1) In December, Harold Boley and I discussed some of the discriminators 
in Sections 1 and 2  of the RAF document, Syntactic and 
Syntactic-Entailing-Semantic Discriminators. It appeared from our 
discussion that the distinction between these categories was not always 
clear, and that perhaps these categories should be re-organized or 
restructured.  (Harold, please correct me if I am incorrect.)

In addition, it was not clear why certain syntactic features, but not 
others, were called out in the RAF document. For example,  why (Section 
1.3) are Monotonic Lloyd-Topor Extensions specifically mentioned, as 
opposed to other types of syntactic sugars?

(2) Section 5,  Discriminators for Event-Condition-Action (ECA) Rules. The 
discriminators listed here may not include all those that are of interest, 
and may not necessarily structure them in the best way. For example, the 
list for 5.2.7, "Which type of event specification is used in the 
language?" lists as the set of possible choices algebraic, linear temporal 
logic, event calculus, and other.  Linear temporal logic is an entirely 
different animal from the event calculus. A better structure might compare 
linear temporal logic with languages that have explicit notions of action 
and causation; this class of languages include situation calculus, fluent 
calculus, and event calculus, among many others. As another example, it 
may be useful to distinguish between languages that explictly mention time 
points and/or intervals from those that don't. This important concept, 
which one would expect to find in an ontology of ECA languages (and 
indeed, in an ontology of time), is not implicit in this set of 
discriminators.

What all of this serves to underscore is that our job in ontologizing the 
RIFRAF is not merely to decide how to structure the discriminators that 
exist, but to try to collect as many possibly relevant discriminators as 
we can. How we proceed in this enterprise is something that we ought to 
discuss.

Best regards,
Leora




Axel Polleres <axel.polleres@urjc.es> 
Sent by: public-rif-wg-request@w3.org
01/22/2007 07:42 PM
Please respond to
axel


To
W3C RIF WG <public-rif-wg@w3.org>
cc

Subject
Re: [RIFRAF] ho to proceed? Part I: Ontologization






> 1) First, I will try to get something towards ontologization out of the
> whole core discussion, and raise some open questions there.


We agreed that several people take over parts of the ontologization
according to the sections of the questionnaire [3].

   Supposedly, an overall ontology on what is a rule, condition, head,
body, etc. would be a starting point for axiomatizing the
discruiminators mentioned there.
Thus, for giving it a start, I concentrated to modeling conditions and
what is currently in the core properly for the moment.
   I picked up a rudimentary attempt by Sandro [1] and started to
additionally "OWLify" what I found in the last core version [2].
Find the result as an attachment.
If you think this approach makes sense, we could maybe further develop
this jointly using subversioning or similar versioning software...


Just to demonstrate why I think this is a valid starting point for
defining axioms concerning discriminators in the current RIFRAF,
and in which direction this could go let's look at the following
question/discriminator from [3]:

"1.2 Predicate Variables Permitted vs. Not Permitted
Does your language allow predicate variables? [...]"

This could be "axiomatized" somewhat as follows using the basic
ontology started now by stating (I use some F-Logic-style syntax here,
just to get to the point, hope it is readable enough):

=======================================================================
% Axiomatizing 1.2 in the rifraf ontology:

% PredVarNotPermitted is a subclass of Language
predVarNotPermitted::Language.


% Define an  auxiliary predicate to "collect" recursively
% all "subConditions":

forall C, C1. C[hasCondition -> C1] implies C[hasSubCondition -> C1]

forall C. C[hasCondition -> C1[hasSubCondition -> C2] implies
             C[hasSubCondition -> C2]


% Finally the rule which disallows variales for the
% predVarNotPermitted languages:

forall L, R,C,F.
( L:predVarNotPermitted and
    R[hasRecCondition->C:ComplexTerm[hasFunctor->F:Variable]]
)
implies
neg R[expressibleIn->L]
=======================================================================

   Main open issues are:

a) Well, this probably looks a lot like Sandro's attempts to make an
abstract syntax notation which is not surprising.

b) I came to some limits very quickly, e.g.
    How do I express that a parameter has at least one position or functor
    describing the argument-name. This can be done in OWL, but not in
    protege (without adding a new class). Likewise, I am unsure whether
    the 1.2 axiomatization above can be encoded in OWL properly.

c) Is this exercise useful or shall we wait until we have the core
     fixed before continuing?
     For instance: When we go further towards e.g. events, one has to ask
     him/herself for instance whether events are a subclass of "condition"
     or something different? How can I axiomatize in an extensible way
     that Core rule has no events in its body, etc.
     It seems to me that for expressing this, I need integrity constraints
     not expressible in OWL...

FWIW, I would like to discuss the general approach before continuing,
honestly.

best,
axel

1. http://lists.w3.org/Archives/Public/public-rif-wg/2006Oct/0093
2. http://www.w3.org/2005/rules/wg/wiki/CORE?action=recall&rev=14
3. http://www.w3.org/2002/09/wbs/38457/RAFQuestionnaire/

-- 
Dr. Axel Polleres
email: axel@polleres.net  url: http://www.polleres.net/



<?xml version="1.0"?>
<rdf:RDF
    xmlns="http://www.w3.org/2006/10/rifraf#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:p1="http://www.owl-ontologies.com/assert.owl#"
    xmlns:dc="http://purl.org/dc/elements/1.1/"
  xml:base="http://www.w3.org/2006/10/rifraf">
  <owl:Ontology rdf:about="">
    <rdfs:label rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >RIFRAF</rdfs:label>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >This is an early and development draft of an ontology of rule 
systems, being developed by the W3C Rule Interchange Format (RIF) Working 
Group.</rdfs:comment>
    <rdfs:seeAlso rdf:resource="http://www.w3.org/2005/rules/wg"/>
  </owl:Ontology>
  <owl:Class rdf:ID="ComplexTerm">
    <rdfs:subClassOf>
      <owl:Restriction>
        <owl:onProperty>
          <owl:ObjectProperty rdf:ID="hasFunctor"/>
        </owl:onProperty>
        <owl:allValuesFrom>
          <owl:Class rdf:ID="Term"/>
        </owl:allValuesFrom>
      </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
      <owl:Class rdf:ID="Litform"/>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
      <owl:Restriction>
        <owl:cardinality rdf:datatype="
http://www.w3.org/2001/XMLSchema#int"
        >1</owl:cardinality>
        <owl:onProperty>
          <owl:ObjectProperty rdf:about="#hasFunctor"/>
        </owl:onProperty>
      </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf rdf:resource="#Term"/>
  </owl:Class>
  <owl:Class rdf:ID="System"/>
  <owl:Class rdf:ID="AllAtOnceSolutionProducer">
    <owl:disjointWith>
      <owl:Class rdf:ID="SequentialSolutionProducer"/>
    </owl:disjointWith>
    <rdfs:subClassOf>
      <owl:Class rdf:ID="SolutionProducer"/>
    </rdfs:subClassOf>
  </owl:Class>
  <owl:Class rdf:ID="Parameter">
    <owl:disjointWith>
      <owl:Class 
rdf:ID="InvalidParameter_should_be_disjointwithOWLThing"/>
    </owl:disjointWith>
    <rdfs:subClassOf>
      <owl:Restriction>
        <owl:maxCardinality rdf:datatype="
http://www.w3.org/2001/XMLSchema#int"
        >1</owl:maxCardinality>
        <owl:onProperty>
          <owl:ObjectProperty rdf:ID="hasParamValue"/>
        </owl:onProperty>
      </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
      <owl:Restriction>
        <owl:onProperty>
          <owl:DatatypeProperty rdf:ID="hasParamPos"/>
        </owl:onProperty>
        <owl:maxCardinality rdf:datatype="
http://www.w3.org/2001/XMLSchema#int"
        >1</owl:maxCardinality>
      </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
      <owl:Restriction>
        <owl:maxCardinality rdf:datatype="
http://www.w3.org/2001/XMLSchema#int"
        >1</owl:maxCardinality>
        <owl:onProperty>
          <owl:ObjectProperty rdf:about="#hasFunctor"/>
        </owl:onProperty>
      </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
  </owl:Class>
  <owl:Class rdf:ID="Condition"/>
  <owl:Class rdf:ID="Conjunction">
    <rdfs:subClassOf rdf:resource="#Condition"/>
  </owl:Class>
  <owl:Class rdf:ID="Quantif">
    <rdfs:subClassOf>
      <owl:Restriction>
        <owl:onProperty>
          <owl:ObjectProperty rdf:ID="hasVariable"/>
        </owl:onProperty>
        <owl:minCardinality rdf:datatype="
http://www.w3.org/2001/XMLSchema#int"
        >1</owl:minCardinality>
      </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
  </owl:Class>
  <owl:Class rdf:ID="SlottedRIFCoreTerm">
    <rdfs:subClassOf>
      <owl:Class rdf:ID="FirstOrderComplexTerm"/>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
      <owl:Restriction>
        <owl:onProperty>
          <owl:ObjectProperty rdf:ID="hasParameter"/>
        </owl:onProperty>
        <owl:allValuesFrom>
          <owl:Restriction>
            <owl:cardinality rdf:datatype="
http://www.w3.org/2001/XMLSchema#int"
            >1</owl:cardinality>
            <owl:onProperty>
              <owl:ObjectProperty rdf:about="#hasFunctor"/>
            </owl:onProperty>
          </owl:Restriction>
        </owl:allValuesFrom>
      </owl:Restriction>
    </rdfs:subClassOf>
  </owl:Class>
  <owl:Class rdf:ID="RIFCoreHornRule">
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >We need to define several restrictions here, first that the Head and 
body are exactly defined by a condition and a Litform.
Second, that all ComplexTerms occurring in such a rule are 
FirstOrderComplexTerms.</rdfs:comment>
    <rdfs:subClassOf>
      <owl:Class rdf:ID="Rule"/>
    </rdfs:subClassOf>
  </owl:Class>
  <owl:Class rdf:about="#InvalidParameter_should_be_disjointwithOWLThing">
    <owl:equivalentClass>
      <owl:Class>
        <owl:intersectionOf rdf:parseType="Collection">
          <owl:Restriction>
            <owl:onProperty>
              <owl:ObjectProperty rdf:about="#hasParamValue"/>
            </owl:onProperty>
            <owl:cardinality rdf:datatype="
http://www.w3.org/2001/XMLSchema#int"
            >1</owl:cardinality>
          </owl:Restriction>
          <owl:Restriction>
            <owl:onProperty>
              <owl:DatatypeProperty rdf:about="#hasParamPos"/>
            </owl:onProperty>
            <owl:maxCardinality rdf:datatype="
http://www.w3.org/2001/XMLSchema#int"
            >0</owl:maxCardinality>
          </owl:Restriction>
          <owl:Restriction>
            <owl:onProperty>
              <owl:ObjectProperty rdf:about="#hasFunctor"/>
            </owl:onProperty>
            <owl:cardinality rdf:datatype="
http://www.w3.org/2001/XMLSchema#int"
            >0</owl:cardinality>
          </owl:Restriction>
        </owl:intersectionOf>
      </owl:Class>
    </owl:equivalentClass>
    <owl:disjointWith rdf:resource="#Parameter"/>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >This class shoult be a subclass of owl:nothing, i,e. 
invalid.</rdfs:comment>
  </owl:Class>
  <owl:Class rdf:ID="AllQuantif">
    <rdfs:subClassOf rdf:resource="#Quantif"/>
  </owl:Class>
  <owl:Class rdf:about="#Rule">
    <rdfs:subClassOf>
      <owl:Restriction>
        <owl:onProperty>
          <owl:FunctionalProperty rdf:ID="hasBody"/>
        </owl:onProperty>
        <owl:cardinality rdf:datatype="
http://www.w3.org/2001/XMLSchema#int"
        >1</owl:cardinality>
      </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
      <owl:Restriction>
        <owl:cardinality rdf:datatype="
http://www.w3.org/2001/XMLSchema#int"
        >1</owl:cardinality>
        <owl:onProperty>
          <owl:FunctionalProperty rdf:ID="hasHead"/>
        </owl:onProperty>
      </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
  </owl:Class>
  <owl:Class rdf:ID="UnorderedRuleSet">
    <rdfs:subClassOf>
      <owl:Class rdf:ID="RuleSet"/>
    </rdfs:subClassOf>
  </owl:Class>
  <owl:Class rdf:ID="ForwardChainingSystem">
    <rdfs:subClassOf>
      <owl:Class rdf:ID="ChainedInferenceSystem"/>
    </rdfs:subClassOf>
  </owl:Class>
  <owl:Class rdf:ID="Equality">
    <rdfs:subClassOf>
      <owl:Class rdf:about="#Litform"/>
    </rdfs:subClassOf>
  </owl:Class>
  <owl:Class rdf:ID="Action"/>
  <owl:Class rdf:ID="TypedVariable">
    <rdfs:subClassOf>
      <owl:Class rdf:ID="Variable"/>
    </rdfs:subClassOf>
  </owl:Class>
  <owl:Class rdf:ID="PositionalRIFCoreTerm">
    <rdfs:subClassOf>
      <owl:Class rdf:about="#FirstOrderComplexTerm"/>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
      <owl:Restriction>
        <owl:onProperty>
          <owl:ObjectProperty rdf:about="#hasParameter"/>
        </owl:onProperty>
        <owl:allValuesFrom>
          <owl:Restriction>
            <owl:cardinality rdf:datatype="
http://www.w3.org/2001/XMLSchema#int"
            >1</owl:cardinality>
            <owl:onProperty>
              <owl:DatatypeProperty rdf:about="#hasParamPos"/>
            </owl:onProperty>
          </owl:Restriction>
        </owl:allValuesFrom>
      </owl:Restriction>
    </rdfs:subClassOf>
  </owl:Class>
  <owl:Class rdf:ID="Disjunction">
    <rdfs:subClassOf rdf:resource="#Condition"/>
  </owl:Class>
  <owl:Class rdf:ID="BackwardChainingSystem">
    <rdfs:subClassOf>
      <owl:Class rdf:about="#ChainedInferenceSystem"/>
    </rdfs:subClassOf>
  </owl:Class>
  <owl:Class rdf:ID="OrderedRuleSet">
    <rdfs:subClassOf rdf:resource="#RuleSet"/>
  </owl:Class>
  <owl:Class rdf:about="#FirstOrderComplexTerm">
    <rdfs:subClassOf>
      <owl:Restriction>
        <owl:onProperty>
          <owl:ObjectProperty rdf:about="#hasFunctor"/>
        </owl:onProperty>
        <owl:allValuesFrom>
          <owl:Class rdf:ID="Constant"/>
        </owl:allValuesFrom>
      </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf rdf:resource="#ComplexTerm"/>
  </owl:Class>
  <owl:Class rdf:ID="ExistQuantif">
    <rdfs:subClassOf rdf:resource="#Quantif"/>
  </owl:Class>
  <owl:Class rdf:about="#Variable">
    <rdfs:subClassOf rdf:resource="#Term"/>
    <owl:disjointWith>
      <owl:Class rdf:about="#Constant"/>
    </owl:disjointWith>
  </owl:Class>
  <owl:Class rdf:about="#SequentialSolutionProducer">
    <rdfs:subClassOf>
      <owl:Class rdf:about="#SolutionProducer"/>
    </rdfs:subClassOf>
    <owl:disjointWith rdf:resource="#AllAtOnceSolutionProducer"/>
  </owl:Class>
  <owl:Class rdf:ID="Event"/>
  <owl:Class rdf:about="#SolutionProducer">
    <rdfs:subClassOf rdf:resource="#System"/>
  </owl:Class>
  <owl:Class rdf:ID="Body">
    <rdfs:subClassOf>
      <owl:Restriction>
        <owl:maxCardinality rdf:datatype="
http://www.w3.org/2001/XMLSchema#int"
        >1</owl:maxCardinality>
        <owl:onProperty>
          <owl:ObjectProperty rdf:ID="hasCondition"/>
        </owl:onProperty>
      </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
  </owl:Class>
  <owl:Class rdf:about="#ChainedInferenceSystem">
    <rdfs:subClassOf rdf:resource="#System"/>
  </owl:Class>
  <owl:Class rdf:about="#Litform">
    <rdfs:subClassOf rdf:resource="#Condition"/>
  </owl:Class>
  <owl:Class rdf:about="#Constant">
    <rdfs:subClassOf rdf:resource="#Term"/>
    <owl:disjointWith rdf:resource="#Variable"/>
  </owl:Class>
  <owl:Class rdf:ID="Head">
    <rdfs:subClassOf>
      <owl:Restriction>
        <owl:maxCardinality rdf:datatype="
http://www.w3.org/2001/XMLSchema#int"
        >1</owl:maxCardinality>
        <owl:onProperty>
          <owl:ObjectProperty rdf:about="#hasCondition"/>
        </owl:onProperty>
      </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
  </owl:Class>
  <owl:Class rdf:ID="Language"/>
  <owl:ObjectProperty rdf:about="#hasParameter">
    <rdfs:domain rdf:resource="#ComplexTerm"/>
    <rdfs:range rdf:resource="#Parameter"/>
  </owl:ObjectProperty>
  <owl:ObjectProperty rdf:ID="fullyImplements">
    <rdfs:subPropertyOf>
      <owl:ObjectProperty rdf:ID="implements"/>
    </rdfs:subPropertyOf>
  </owl:ObjectProperty>
  <owl:ObjectProperty rdf:about="#implements">
    <rdfs:domain rdf:resource="#System"/>
    <rdfs:range rdf:resource="#Language"/>
  </owl:ObjectProperty>
  <owl:ObjectProperty rdf:about="#hasCondition">
    <rdfs:range rdf:resource="#Condition"/>
    <rdfs:domain>
      <owl:Class>
        <owl:unionOf rdf:parseType="Collection">
          <owl:Class rdf:about="#Body"/>
          <owl:Class rdf:about="#Conjunction"/>
          <owl:Class rdf:about="#Disjunction"/>
          <owl:Class rdf:about="#Rule"/>
          <owl:Class rdf:about="#Head"/>
        </owl:unionOf>
      </owl:Class>
    </rdfs:domain>
  </owl:ObjectProperty>
  <owl:ObjectProperty rdf:about="#hasFunctor">
    <rdfs:domain>
      <owl:Class>
        <owl:unionOf rdf:parseType="Collection">
          <owl:Class rdf:about="#Parameter"/>
          <owl:Class rdf:about="#ComplexTerm"/>
        </owl:unionOf>
      </owl:Class>
    </rdfs:domain>
    <rdfs:range rdf:resource="#Constant"/>
  </owl:ObjectProperty>
  <owl:ObjectProperty rdf:ID="partiallyImplements">
    <rdfs:subPropertyOf rdf:resource="#implements"/>
  </owl:ObjectProperty>
  <owl:ObjectProperty rdf:ID="expressibleIn">
    <rdfs:range rdf:resource="#Language"/>
    <rdfs:domain rdf:resource="#Rule"/>
  </owl:ObjectProperty>
  <owl:ObjectProperty rdf:about="#hasVariable">
    <rdfs:range rdf:resource="#Variable"/>
    <rdfs:domain>
      <owl:Class>
        <owl:unionOf rdf:parseType="Collection">
          <owl:Class rdf:about="#Rule"/>
          <owl:Class rdf:about="#Quantif"/>
          <owl:Class rdf:about="#Condition"/>
        </owl:unionOf>
      </owl:Class>
    </rdfs:domain>
  </owl:ObjectProperty>
  <owl:ObjectProperty rdf:about="#hasParamValue">
    <rdfs:domain rdf:resource="#Parameter"/>
    <rdfs:range rdf:resource="#Term"/>
  </owl:ObjectProperty>
  <owl:DatatypeProperty rdf:about="#hasParamPos">
    <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#int"/>
    <rdfs:domain rdf:resource="#Parameter"/>
  </owl:DatatypeProperty>
  <owl:FunctionalProperty rdf:about="#hasBody">
    <rdfs:domain rdf:resource="#Rule"/>
    <rdfs:range rdf:resource="#Body"/>
    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#ObjectProperty
"/>
  </owl:FunctionalProperty>
  <owl:FunctionalProperty rdf:about="#hasHead">
    <rdfs:range rdf:resource="#Body"/>
    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#ObjectProperty
"/>
    <rdfs:domain rdf:resource="#Rule"/>
  </owl:FunctionalProperty>
  <Language rdf:ID="N3">
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >The N3 language, from Tim Berners-Lee (timbl@w3.org)</rdfs:comment>
  </Language>
  <Language rdf:ID="Language_3"/>
  <System rdf:ID="cwm">
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >The cwm Semantic Web reasoner</rdfs:comment>
    <fullyImplements rdf:resource="#N3"/>
    <rdf:type rdf:resource="#ForwardChainingSystem"/>
    <rdf:type rdf:resource="#AllAtOnceSolutionProducer"/>
  </System>
</rdf:RDF>

<!-- Created with Protege (with OWL Plugin 3.2.1, Build 365)  
http://protege.stanford.edu -->
Received on Tuesday, 23 January 2007 16:22:36 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Tuesday, 2 June 2009 18:33:35 GMT