RIF Production Rule Dialect

1 Overview

). 1.1.1.1 Introduction

***Editor's Note: General introduction to be developed.

*** 1.2.1.2 Overview of RIF production rule dialect

To be updated following restructuring of the draft The RIF production rule dialect (RIF-PRD) follows the above general modelTBD

1.2.1 RIF-PRD as an interchange format for production rules

and rulesets closely. As a consequence, RIF-PRD specifies two sublanguages: the RIF-PRD condition language, which extends the RIF-Core ([ RIF-Core]) [ condition language], determines what can appear in the condition of a rule supported by RIF-PRD; the RIF-PRD action language, which extends the RIF-PRD condition language, determines what can appear in the action part of a rule supported by RIF-PRD. RIF-PRD extends these sublanguages to specify the interchange format for production rules and rulesets. 1.2.1. RIF-PRD as an interchange format for production rules ***Editor's Note: Overview of PRD and its semantics to be developed

*** 1.2.2.1.2.2 RIF-PRD as a Web language

1.2.3 Compatibility with other RIF dialects

To ensure compatibility with RIF Core dialect ([ RIF-Core]) and its extensions, the RIF production rule language (RIF-PRD) does not draw a sharp boundary between the symbols used to denote individuals from symbols used as names for functions or predicates. Instead, all constant, predicate, and function symbols are drawn from the same universal set. The framework for logic-based RIF dialects RIF-FLD explains how RIF logic dialects control the contexts in which the different symbols can occur by attaching signatures to these symbols. *** "Individual"? "Object"? The intention is to make it clear that constants may stand for something more complex that a single, simple value, and I would fear that using "object" might be too specific, e.g. what about records, etc? Anyway, whatever terminology we use must be consistent and defined. *** In RIF-PRD, individuals, constants, functions and predicates behave as if they were drawn from different sets and signatures are not part of the RIF-PRD language. *** Or should we just drop that section altogether? *** 1.2.4.TBD

1.2.4 Syntaxes

In this document we will introduce twothree related but distinct representations for RIF-PRD components:

Structural diagrams. The overall structure of the1.2.4.1 XML syntax

used in RIF-PRD will be presented as UML diagrams.This syntax is the diagrams are used to introduce RIF-PRD syntactic classesnormative XML serialization of RIF-PRD. It is meant, and has been designed, to show atwork as a glance how they relate to each others.common XML serialisation for many production rule languages.

Three kinds of syntactic components are used to specify RIF-PRD:

1.2.4.2 Presentation syntax

A presentation syntax is also specified, to allow a more easily readable presetation of RIF-PRD language fragments (such as examples etc). The presentation syntax is used mainly to specify the intended semantics of RIF-PRD rulesets. It is non normative.

1.2.4.3 Structural diagram

The overall structure of the syntax of RIF-PRD is also presented as an UML-like diagram in appendix [ XXX]. The diagram provides an overview of RIF-PRD syntactic classes and shows at a glance how they relate to each others.

1.3 Overview of this document

TBD

1.3.1 Namespaces

*** 2. Condition Language (Editor's Note: This text is maintained on wiki page Condition Language ). This section specifies1.3.2 Running example

Jim the language of expressions thatHen Handler developed a very sophisticated program to grow feeble chicks into deliciously plump chickens for a minimal cost. Jim publishes his method on his Web site www.juicychicken.org. Since he is usedstill experimenting to representimprove his method, the different components of a rule supported by RIF-PRD.rules to follow change quite often, and Jim decided to publish them in RIF as well, so that his followers can easily, even automatically, implement the languagevery latest version.

Jim's latest addition to his knowledge base is calledthe language of conditions , because it extendsfollowing advice:

Except on Tuesdays, every potato owned by a chicken gets mashed, and the language of conditionsdaily grain allowance of [ RIF-Core],every chicken that determines what can appear as a condition inowns a rule supportedpotato is increased by RIF-Core.10%, if the language plays a similar role in RIF-PRD. Inchicken is older than 8 months, the first part of this section, the syntax of RIF-PRD condition languagepotato's weight (in decigrams) is specified non-normatively: the normative reference formore than half the XML syntaxchicken's age (in months), and there is the [ XML schema].no fox in the second part, the normative semantics of RIF-PRD condition language is specified. 2.1. Syntaxhen house. Do not forget to delete the overall structure ofmashed potatoes from the syntax used to representownership table!

Jim calls it the condition part of production rules"Chicken and Mashed Potatoes", or CMP, rule. Rephrased in RIF-PRD condition sublanguagea more "rule-like" form, the rule could read like:

Rule ChickensAndMashedPotatoes:

Forall ?c, where ?c is depicted ona chicken and the following diagram. *** Should we have structural diagramsage of ?c in PRD, or should we rather align on BLDmonths is > 8;

Forall ?p, where ?p is a potato, ?p is owned by ?c, and the weight in decigrams of ?p > (age of ?c)/2;

If today is not have them (or should we align BLDTuesday, and add themthere is no fox in BLD)? ***the most basic construct in RIF ishen house

Then mash ?p, increase the TERM .grain allowance of ?c by 10%, and remove the TERM is an abstract construct, concretly visible, in RIF-PRD, as a Const , a Var or an ExtTerm .couple (?c, ?p) from the ATOMIC isownership relation.

The basic building block of RIF. ATOMIC is an abstract class: itCMP rule is visible in RIF-PRD as either an Uniterm , an ExtTerm , an Equal , a Member , a Subclass ora Frame . Notice that, for clarity, onlyproduction rule: that is, when the basic form ofrule is implemented and the Frame constructcondition is represented insatisfied, the diagram: in addition,consequence is that some actions are executed (mashing potatoes, modifying a chicken's regime, managing ownership relations etc). Therefore, it is best interchanged using the syntaxproduction rule dialect of RIF-PRD condition language allowsRIF, and Jim the representation of nestedHen Handler's method, and especially his "chicken and composite Frame s. However, a nestedmashed potatoes" rule and composite Frame can alwayscomponents thereof, will be representedused as a conjunction of basic Frame s and other ATOMIC constructs. Each kind of ATOMIC isrunning example in this document.

To make sure that his rules can be implemented unambiguously, Jim (the Hen Handler, not the chicken) published a composition of TERM s. The next leveldata model (e.g., an XML schema) that identifies Chicken and Potato as two classes of constructs are assembliesobjects:

• instances of ATOMIC s. Together,Chicken represent individual chickens. They have a property called age that represents the various kinds of assemblies formchicken's age in months as an xs:decimal and a property called allowance that represent the abstract construct CONDITION . RIF-PRD knows five kindschicken's daily grain allowance as an xs:integer;
• instances of CONDITION s: the single ATOMIC , andPotato represent individual potatoes. They have a property called weight that represents the recursively specified And , Or , Naf and Existspotato's weight in decigram as an xs:decimal.

The Exists construct also belongs to the QUANTIFICATION abstract class,Jim further specifies:

• a data type DayOfTheWeek that specifies the notionsdays of variable binding andthe week as a subset of an Aggregation .xs:string
• a binary predicate owns(?o ?i) that denotes the following sections specify each construct separately, grouped by abstract syntactic classes. Each element is given an XML syntax, inownership relation between owner ?o and owned item ?i;
• a nullary function today() that returns the formday of the week as a BNF pseudo schema;DayOfTheWeek;
• a presentation syntax,boolean fox sensor foxAlarm() that returns true if and only if the fox is in the form of an EBNF production;hen house;
• and a description ofcommand mash(?i), which execution results in the intended use of each construct,physical item that is, informally,is denoted by ?i being reduced to a soft pulpy state by beating or pressure (and removed from the instances of its semantics. None ofclass, as a consequence).

All these is normative: the normative XML syntax is given in the [ RIF-PRD XML schema](types and the normative semanticsnames) are defined in Jim's namespace, which is givenrepresented in this document by the prefix jim:.

2 Syntax

2.1 Condition Language

This section [ Operational semantics]. 2.1.1. TERMspecifies the TERM class of constructsXML syntax that is used to represent constants, variables andthe applicationdifferent boolean expressions that can be found in production rules. The language is called the language of conditions, because it extends the language of conditions of [ RIF-Core], that determines what can appear as a condition in a rule supported by RIF-Core. The language plays a similar role in RIF-PRD.

The most basic construct in RIF is the TERM. The TERM is an abstract construct, concretly visible, in RIF-PRD, as a Const, a Var or an External.

The ATOMIC is the basic building block of RIF. ATOMIC is an abstract class: it is visible in RIF-PRD as either an Atom, an Equal, a Member, a Subclass or a Frame. Each kind of ATOMIC is a composition of function symbols to otherTERMs.

The next level of constructs are assemblies of ATOMICs. Together, the various kinds of assemblies form the abstract construct FORMULA. RIF-PRD knows six kinds of FORMULAs: the single ATOMIC, the Externallly evaluated atomic relation, and the recursively specified And, Or, Naf and Exists.

The following sections specify each construct separately, grouped by abstract syntactic classes. Each element is given an XML syntax.syntax, in the form of an informative BNF pseudo schema: the normative XML syntax is given in the [ RIF-PRD XML schema].

2.1.1 TERM

The TERM class of constructs is used to represent constants, variables and the application of function symbols to other TERMs.

As an abstract class, TERM is not associated with specific XML markup in RIF-PRD instance documents. It is specified in the normative schema as a substitution group.

***Editor's Note: ...Substitution group or another construct, depending on how we handle extensibility in the XML schema.

     ***[ Const | Var |  ExtTermExternal ]

***Editor's Note: Difference wrt RIF-BLD: in RIF-PRD, there are no logic functions =>=> a TERM cannot be a (non evaluated) Uniterm. *** *** Difference wrt RIF-BLD: The latest version of BLD seems to allow any COUMPOUND (ex-ATOMIC) as TERM. As this has not been discussed yet, that idfference is not commented here. *** Presentation syntax . TERM ::= Const | Var | ExtTerm 2.1.1.1.Expr.

2.1.1.1 Const

In RIF, the Const construct is used to represent a constant.

The constant is represented by a character string; it is associated with an identifier of the constant's type and, optionally where permitted, a language identifier. XML syntax. TheConst element has a required type attribute and an optional xml:lang attribute:

2.1.1.2 Var

In RIF, the Var construct is used to represent variables.

XML syntax.The content of the Var element is the variable's name, represented as an Unicode character string.

***Editor's Note: Shouldn't variable's names rather be limited to be, e.g. xs:NMTOKEN?

     *** <Var><Var> xs:NMTOKEN  </Var> ***</Var>

Editor's Note: Or should Var have a type attribute (and we could, maybe, get rid of the Member construct)?

*** ***Editor's Note: Difference wrt RIF-BLD: RIF-BLD says only that a Var element contains a VARNAME. However, most implemented rule languages enforce some syntactic restrictions on the name of variables and requiring all RIF implementations to support any Unicode string as VARNAMEs might be an additional burden with little benefits associated. This is a proposed alternative: whatever the decision, BLD and PRD should use the same definition.

*** Presentation syntax. Var ::= VARNAME *** Difference wrt RIF-BLD: BLD says Var ::= '?' VARNAME : according to that production, wouldn't a variable that is named ?X in a rule become ??x in RIF? This is a proposed alternative: whatever the decision, BLD and PRD should use the same definition. *** Informal semantics. The semantics of the variable that is represented by a Var element is specified by a variable binding that maps the variable to a value or an individual. *** What about binding to variables too? (AdrianP) *** 2.1.1.3. ExtTerm2.1.1.3 External

As a TERM, an ExtTermExternal element is used to represent an evaluated function.

***Editor's Note: builtin function, evaluated function, or fixed interpretation function... need consistent terminology (Gary)

*** As explainedThe External element contains one content element, which in turn contains one Expr element that contains one op</tt> element, followed by zero or more arg elements:

• The Overview , for compatibility reasons, individuals, function symbolscontent and predicate symbols in RIF, all belong to the same set of constants. As a consequence, the same ExtTerm construct is used to represent both evaluated functions and evaluated predicates (or relations). However, this is more general than what is needed in RIF-PRD: in RIF-PRD, the ExtTerm construct can only be used to represents an evaluated function when it is a TERMExpr element ensure compatibility with [ RIF Basic Logic Dialect], that allows non-evaluated (that is, in particular, when it appears in a place where a TERM is required). XML syntax. The ExtTerm element contains one op element, followedlogic) functions to be represented by zero or more arg elements:an Expr element;

• The content of the op element must be a construct from the TERM abstract class. When the ExtTermExternal is a TERM, the content of the op element represents a function symbol;

***Editor's Note: Or should the op element be restricted to contain a Const element only?

• ***The content of the arg elements must be constructs from the TERM abstract class. The order of the arg elements is significant and MUST be preserved.

     <ExtTerm> <op> TERM </op> <arg> TERM </arg>* </ExtTerm> ***<External>
       <content>
          <Expr>
             <op> TERM </op>
             <arg> TERM </arg>*
          </Expr>
       </content>
    </External>

Editor's Note: Difference wrt RIF-BLD: This version of the construct for representing builtinsPRD draft does not seem to be included in RIF-BLD yet. The label ExtTerm is useduse named argument UNITERMs.

Editor's Note: Difference wrt RIF-BLD: Since PRD does not have logical function (non-External Expr, in the syntax proposalsBLD), it could be a good case for fallbacks to replace, in PRD, the List of BLD built-ins . This is<External><content><Expr> cascade by a proposal: whatever the decision, BLD and PRD should use the same definition.*** Presentation syntax. ExtTerm ::= ' Builtin( ' TERM ' ( ' TERM* ' )) ' *** The problem with the "Builin" notation is that all fixed interpretation functions need not be builtin... ***single equivalent <Function> element.

Builtin functions. RIF-PRD specifies a subset of XPath/XQuery Functions and Operators [X F&O] that any conformant RIF-PRD implementation MUST support. The RIF-PRD builtin functions are listed in the appendix[ List of Builtin FunctionsData Type and Operators]. Informal semantics . ExtTerm s are usedBuiltins] document.

Editor's Note: TBC how to represent procedural attachments: their semantics is always specified outside of a RIF instance document where they appear.reference non-builtin evaluated functions

The op TERM must represent a constant symbol of type rif:iri that must uniquely identify the evaluated function to be applied to the arg TERMs. It can be one of the builtin functions specified for RIF-PRD, or it can be application specific. In the latter case, it is the responsibility of the producers and consumers of RIF-PRD rulesets that reference non-builtin functions to agree on their semantics.

An evaluated function applied to arguments in its domain of definition evaluatesExamples.

a. The first example below shows one way to a constant valuerepresent, in its range: subject toRIF-PRD, the binding of its variable arguments, the external call represented by an ExtTerm TERM is another equivalent representation of that constant. Arguments out of the domain of definition. For arguments out of its domain of definition, the value of an evaluated function is not defined. RIF-PRD does not specify any expected behaviour for that case: it is the responsibility of the consummer of a RIF-PRD ruleset to know the expected behaviour or to handle the error. Examples. The example below shows one way to represent, in RIF-PRD, the sumsum of integer 1 and variable ?X,variable ?X, where the addition conforms to the specification of the builtin fn:numeric-add.

The prefix fn is associated with the namespace http://www.w3.org/2005/xpath-functions.

 XML syntax. <ExtTerm> <op><External>
   <content>
      <Expr>    
         <op> <Const  type="rif:iri">type="rif:iri"> fn:numeric-add  </Const> </op> <arg></Const> </op>
         <arg> <Const  type="xsd:integer">type="xsd:integer"> 1  </Const> </arg> <arg> <Var></Const> </arg>
         <arg> <Var> ?X  </Var> </arg> </ExtTerm> Presentation syntax. Builtin(fn:numeric-add^^rif:iri(1^^xsd:integer ?X)) 2.1.2.</Var> </arg>
      </Expr>
   </content>
</External>

b. Another example, that shows the RIF XML representation of a call to the application-specific nullary function today(), which symbol is defined in the example's namespace:

<External>
   <content>
      <Expr>    
         <op> <Const type="rif:iri"> jim:today </Const> </op>
      </Expr>
   </content>
</External>

2.1.2 ATOMIC

The ATOMIC class is used to represent atomic truth-valued statements. RIF-PRD covers rule languages in which the truth values of atomic statements can only be "true""true" or "false":"false": that is, ATOMICs represent boolean statements. Dialects extending RIF-PRD may support additional truth values.

XML syntax.As an abstract class, ATOMIC is not associated with specific XML markup in RIF-PRD instance documents. It is specified in the normative schema as a substitution group.

***Editor's Note: ...Substitution group or another construct, depending on how we handle extensibility in the XML schema.

     *** [ Uniterm | ExtTerm | Equal | Member | Subclass | Frame ] *** Difference wrt RIF-BLD: The lates version of BLD changed the name of ATOMIC to COMPOUND. As no decision has been made about this yet (nor about naming in general), this draft keeps by the previous name. Whatever the decision, BLD and PRD should use the same definition. *** Presentation syntax. ATOMIC ::=[  Uniterm | ExtTermAtom | Equal | Member | Subclass | Frame ]

2.1.2.1. Uniterm As explained in the Overview , for compatibility reasons, individuals, function symbols and predicate symbols2.1.2.1 Atom

In RIF, all belong to the same set of constants. As a consequence,the same Uniterm construct could potentially be used to represent functions as well as predicates (or relations). However, this is more general than what is needed in RIF-PRD: in RIF-PRD, an UnitermAtom element is alwaysused to represent a predicate, and it is always an ATOMIC . Other dialects, including extensions of RIF-PRD, may extend this. XML syntax.relation (or predicate).

The UnitermAtom element contains one op element, followed by zero or more arg arguments:

• The content of the op element must be a Constan element thatof the TERM class of construct. It represents the predicate symbol (the name of a relation);
• *** Or should the op element be allowed to be any TERM instead? ***The content of the arg elements must be constructs from the TERM abstract class. The order of the arg elements is significant and MUST be preserved.

     <Uniterm> <op> Const </op> <arg><Atom>
       <op> TERM </op>
       <arg> TERM  </arg>* </Uniterm> ***</arg>*
    </Atom>

Editor's Note: Difference wrt RIF-BLD: Not sure what is the support for relational atoms where the predicate would not be a constant, among production rule languages. Hence the question above. Dependinglanguages: should op be restricted to be a Const? Depending on the answer, it might make sense for PRD to differ from BLD here. The benefits and drawbacks (e.g. wrt the definition of Core) have to be weighted.

*** ***Editor's Note: Difference wrt RIF-BLD: Named arguments Uniterms do not seem to have much support in production rule languages => TheyAtoms are not included in this draft.

PRD and BLD might differ in this respect. A consequence would be that Core would not have named argument Uniterms. *** Presentation syntax. Uniterm ::= Const ' ( ' TERM* ' ) ' Informal semantics . The Uniterm ATOMIC is used to represent an atomic statement that is true iffExample. The individuals or values represented byexample below shows the arg s elements are known to satisfyRIF XML representation of the predicate (relation) represented by the op element. 2.1.2.2. ExtTerm As an ATOMICowns(?c ?p), an ExtTerm is used to represent an evaluated relation. As explained inwhere the Overview , for compatibility reasons, individuals, function symbols andpredicate symbolssymbol owns' is defined in RIF, all belong tothe same set of constants. As a consequence,example namespace denoted by the same ExtTerm constructprefix jim:.

<Atom>
   <op> <Const type="rif:iri"> jim:owns </Const> </op>
   <arg> <Var> ?c </Var> </arg>
   <arg> <Var> ?p </Var> </arg>
</Atom>

2.1.2.2 Equal

In RIF, Equal is used to represent both evaluated functions and evaluated predicates (or relations). However, this is more general than what is needed in RIF-PRD. In RIF-PRD, an ExtTerm represents always an evaluated predicate when it is an ATOMIC (that is, in particular, when it appears in a place where an ATOMIC is required). XML syntax.equality relations.

The ExtTermEqual element contains one op element, followed by zero or more arg arguments: When the ExtTerm is an ATOMIC ,must contain two unordered side elements. The content of the opeach side element must be a construct from the TERM abstract class. When the ExtTerm is an ATOMIC , the content of the op sub-element represents a predicate symbol; *** Or should the op element be restricted to contain a Const element only? ***The contentorder of the argside elements is not significant and must not be constructs from thepreserved.

    <Equal>
       <side> TERM  abstract class.</side>
       <side> TERM </side>
    </Equal>

2.1.2.3 Member

In RIF, the order ofMember element is used to represent membership relations.

The argMember element contains two unordered sub-elements:

• the object elements must be a construct from the TERM abstract class. It is significant andrequired;
• the class element must be preserved. <ExtTerm> <op>a construct from the TERM abstract class. It is required as well.

    <Member>
       <object> TERM  </op> <arg></object>
       <class> TERM  </arg>* </ExtTerm> ***</class>
    </Member>

Editor's Note: Difference wrt RIF-BLD: Same remarkobject and class make more sense to me as wrtthe TERM ÈxtTerm `. *** Presentation syntax. ExtTerm ::= ' Builtin( ' TERM ' ( ' TERM* ' )) ' ***roles in addition to the problem witha membership relation than BLD's lower and upper. But, as noticed earlier, the "Builtin" notation applyingdiscussion about naming is still to fct that maybe user-defined, ishad, and I do not care that much about label's names anyway... This is a proposed alternative: whatever the ExtTerm ::= ' Builtin( ' Uniterm ' ) ' kinddecision, BLD and PRD should use the same definition.

Example. The example below shows the RIF XML representation of confusing? I knowa bollean expression that they are equivalent, but I prefer to keeptests whether the individual denoted by the developed production (CSMA) *** Builtin predicates. RIF-PRD specifiesvariable ?c is a subsetmember of XPath/XQuery Functions and Operators [X F&O] that any conformant RIF-PRD implementation MUST support.the RIF-PRD builtin predicates are listedclass Chicken that is defined in the appendix [ List of Builtin Functions and Operators]. Informal semanticsexample namespace denoted by the prefix jim:.

 ExtTerm s are<Member>
   <object> <Var> ?c </Var> </object>
   <class> <Const type="rif:iri"> jim:Chicken </Const> </class>
</Member>

2.1.2.4 Subclass

In RIF, the Subclass element is used to represent procedural attachments: their semantics is always specified outside of a RIF instance document where they appear.class inclusion relations.

The op TERMSubclass element contains unordered two sub-elements:

• the subClass element must representbe a constant symbol of type rif:iri that must uniquely identifyconstruct from the evaluated predicate to be applied to the arg TERM s.TERM abstract class. It can be one ofis required;
• the builtin predicates specified for RIF-PRD, or it canclass elements must be application specific. Ina construct from the latter case,TERM abstract class. It is up to the producersrequired.

    <Subclass>
       <subClass> TERM </subClass>
       <class> TERM </class>
    </Subclass>

Editor's Note: Difference wrt RIF-BLD: BLD's lower and consumers of RIF-PRD rulesets that reference non-builtin predicates to agree on their semantics. Arguments out ofupper make more sense. I kept class for the domain of definition. An evaluated predicate applied to arguments within its domain of definition evaluates to a truth value.upper element for arguments out of its domain of definition,consistency with the truth value of an evaluated predicate is not defined. RIF-PRD doesMember element, and subClass seemmed to make more sense, associated with class than lower would. But, again, I am not specify any expected behaviour for that case: itreligious about tags. This is the responsibility of the consummer ofa RIF-PRD ruleset to knowproposed alternative: whatever the expected behaviour or to handledecision, BLD and PRD should use the error. 2.1.2.3. Equalsame definition.

2.1.2.5 Frame

In RIF, Equalthe Frame construct is used to represent equality relations. *** Or should RIF-PRD have only evaluated (builtin + application specific) equality relations? *** XML syntax.relations that hold between an individual, also called an object, and the Equalvalues of some its properties or attributes: that is, object-attribute-value triples.

Accordingly, a Frame element must contain two unordered side elements.contain:

• an object element, that contains an element of the TERM abstract class, the content of which represents the individual;
• zero to many slot elements, each sidecontaining a Prop element must bethat represents an attribute-value pair as:
  • a construct fromkey element that contains an element of the TERM abstract class.class that represents the ordername of the attribute (or property);
  • a val element, that contains an element of the side elements is not significant and must not be preserved. <Equal> <side> TERM </side> <side> TERM </side> </Equal> Presentation syntax. Equal ::=TERM ' = 'abstract class, the content of which represents the attribute's value.

    <Frame>
       <object> TERM  Informal semantics.</object>
       <slot> Prop </slot>*
    </Frame>

    <Prop>
       <key> TERM </key>
       <val> TERM </val>
    </Prop>

Example. The Equal element is used to represent a predicateexample below shows the RIF XML syntax of an expression that states that is is true iffthe values or individuals representedobject denoted by the Equal 's side TERM s are equal. 2.1.2.4. Membervariable ?c has the value denoted by the variable ?a for the property Chicken/age that is defined in RIF,the Member elementexample namespace.

<Frame>
   <object> <Var> ?c </Var> </object>
   <slot> 
      <Prop>
         <key> <Const type="rif:iri"> jim:Chicken/age </Const> </key>
         <val> <Var> ?a </Var> </val>
      </Prop>
   </slot>*
</Frame>

Editor's Note: Used an XPath style for the key. This has to be discussed, of course.

2.1.3 FORMULA

The FORMULA class is used to represent membership relations. ***any truth-valued statement, atomic or should RIF-PRD have only evaluated (builtin + application specific) membership relations? *** XML syntax. The Member element contains two sub-elements:not, that is allowed in the object elements must becondition part of a construct fromrule covered by RIF-PRD. In rule languages covered by RIF-PRD, the TERMtruth values of statements can be "true" or "false": that is, FORMULAs can only represent boolean statements.

Dialects extending RIF-PRD may support additional truth values.

As an abstract class.class, FORMULA is not associated with specific XML markup in RIF-PRD instance documents. It is required;specified in the class element must benormative schema as a construct fromsubstitution group.

Editor's Note: ...Substitution group or another construct, depending on how we handle extensibility in the TERM abstract class. It is required as well. <Member> <object> TERM </object> <class> TERM </class> </Member> ***XML schema.

    [ ATOMIC | External | And | Or | NmNot | Exists ]

Editor's Note: Difference wrt RIF-BLD: object and class make more sense to me as the roles ina membership relation than BLD's lower and upper . But, as noticed earlier, the discussion about naming is still to be had, and I do not care that much about label's names anyway... This isRIF-PRD without a proposed alternative: whatever the decision, BLD and PRD should useconstruct for closed-world negation would not make mush sense; hence the same definition. *** Presentation syntax. Member ::= TERM ' # ' TERM Informal semantics.addition, wrt BLD, of the Membernon-monotonic (inflationary) negation NmNot construct. This construct is usedspecific to represent predicates that are true iff therePRD.

2.1.3.1 ATOMIC

A FORMULA can be a single ATOMIC statement. See specification of [ ATOMIC], above.

2.1.3.2 External

In RIF-PRD, an External represents an evaluated predicate when it is a known classification accordingFORMULA (as opposed to which the argumenta TERM; that is represented by the class TERM isis, in particular, when it appears in a classplace where a FORMULA is required, and not a TERM).

The value or individualExternal element contains one content element that is represented by the object TERM iscontains one Atom element:

    <External>
       <content>
          Atom
       </content>
    </External>

Builtin predicates. RIF-PRD specifies a membersubset of XPath/XQuery Functions and Operators [X F&O] that class. 2.1.2.5. Subclass In RIF,any conformant RIF-PRD implementation MUST support. The Subclass element is used to represent class inclusion relations. *** Or shouldRIF-PRD have onlybuiltin predicates are listed in the[ Data Types and Builtins] document.

Editor's Note: TBC how to reference non-builtin evaluated (builtin + application specific) subclass relations? *** XML syntax.predicates

The Subclass element contains two sub-elements:op TERM in the subClassAtom element must berepresent a construct from the TERM abstract class. It is required as well; the class elementsconstant symbol of type rif:iri that must be a construct fromuniquely identify the TERM abstract class.evaluated predicate to be applied to the arg TERMs. It is required. <Subclass> <subClass> TERM </subClass> <class> TERM </class> </Subclass> *** Difference wrt RIF-BLD: BLD's lower and upper make more sense. I kept class forcan be one of the upper elementbuiltin predicates specified for consistency withRIF-PRD, or it can be application specific. In the Member element, and subClass seemmed to make more sense, associated with class than lower would. But, again, I am not religious about tags. Thislatter case, it is a proposed alternative: whateverup to the decision, BLDproducers and PRD should use the same definition. *** Presentation syntax. Subclass ::= TERM ' ## ' TERM Informalconsumers of RIF-PRD rulesets that reference non-builtin predicates to agree on their semantics.

2.1.3.3 And

A FORMULA can represent the valueconjunction of onezero of its properties or attributes: that is, object-attribute-value triples. XML syntax. Accordingly, in its basic form,more statements, each of them represented by a FrameFORMULA. This is represented by the And construct.

The And element must contain: an object element, thatcontains an element of the TERM abstract class, the contentzero or more formula elements, each containing an element of which representsthe individual; a slotKey element, that containsFORMULA group.

    <And>
       <formula> FORMULA </formula>*
    </And>

2.1.3.4 Or

A Const element that representsFORMULA can represent the namedisjunction of zero of more statements, each of them represented by a FORMULA. This is represented by the attribute (or property); ***Or shouldconstruct.

The slotKeyOr element be allowed to contain any TERM instead? *** a slotValue element, thatcontains zero or more formula elements, each containing an element of the TERM abstract class,FORMULA group.

    <Or>
       <formula> FORMULA </formula>*
    </Or>

2.1.3.5 NmNot

A FORMULA can represent the contentnon-monotonic negation of which represents the attribute's value. *** Or should empty frames be allowed (and, thus, the slotKey-slotValue pair optional)? If yes: how to forbida slotKey element withoutstatement, itself represented by a slotValue, or reciprocally, without breakingFORMULA: this is represenetd by the striping? *** <Frame> <!-- Basic form --> <object> TERM </object> <slotKey> Const </slotKey> <slotValue> TERM </slotValue> </Frame> *** Difference wrt RIF-BLD: in RIF-BLD, a basic Frame has only two sub-elements: object and slot ; where slot has two contents:NmNot construct.

The key andNnNot element contains exactly one formula element. The filler. Althoughformula element contains an element of the XML syntax has not been discussed yet, I supposeFORMULA group, that represents the rationalenegated statement.

    <NnNot>
       <formula> FORMULA </formula>
    </NmNot>

Editor's Note: Difference wrt RIF-BLD: that construct is specific to preserveRIF-PRD. I used a different name form the associationtwo kinds of the value to the key, but, on the other hand, it seemsnegations specified in FLD (Not and Naf) for fear of snippers: naming remains to breakbe discussed, anyway.

2.1.3.6 Exists

In RIF, the stripping. So, hereExists construct is used to represent an alternative proposal, that preserve the stripping, but whereexistentially quantified FORMULA.

The associationExists element contains:

• one or more declare sub-elements, each containing a Var element that represents one of value to key has to be preserved bythe implementation. This is a proposed alternative: whateverexistentially quantified variables;
• exactly one required formula sub-element that contains an element from the decision, BLD and PRD should useFORMULA abstract class: the same definition. *** *** Difference wrt RIF-BLD: Not sure what isFORMULA represents the support for Frames whereformula in the slot name would not be a constant, among production rule languages. Hencescope of the question above. Depending onquantifier.

    <Exists>
       <declare> Var </declare>+
       <formula> FORMULA </formula>
    </Exists>

Example. The answer,example below shows the RIF XML representation of a boolean expression that tests whether PRD and BLD should differ will be considered. *** *** Difference wrt RIF-BLD: Not sure aboutthe semanticschicken denoted by variable ?c is older than 8 months, by testing the existence of an empty Frame (no slot/value pair); and not surea value, denoted by variable ?a, that it would beis both the sameage of ?c, as represented by a Frame as in BLD and PRD. Hence the question. Not sure about PRDexample XX, and BLD differeng ongreater than 8, as represented by an External ATOMIC as in example YY.

<Exists>
   <declare> <Var> ?a </Var> </declare>
   <formula>
      <And>
         <Frame>
            <object> <Var> ?c </Var> </object>
            <slot> 
               <Prop>
                  <key> <Const type="rif:iri"> jim:Chicken/age </Const> </key>
                  <val> <Var> ?a </Var> </val>
               </Prop>
            </slot>*
         </Frame>
         <External>
            <content>
               <Atom>    
                  <op> <Const type="rif:iri"> op:numeric-greater-than </Const> </op>
                  <arg> <Var> ?a </Var> </arg>
                  <arg>  <Const type="xsd:decimal"> 8 </Const> </arg>
               </Atom>
            </content>
         </External>
      </And>
   </formula>
</Exists>

2.2 Actions

This one, either. *** However,section specifies the XML syntax of the Frame element allows alsothat is used in RIF-PRD to represent compactlywhat can appear in the predicationaction part of multiple object-attribute-value triples fora rule supported by RIF-PRD.

Editor's Note: Difference wrt RIF-BLD: all the same object.constructs in that compact form, the frame element containsthis section are specific to RIF-PRD.

Editor's Note: What about truth maintenance capabilities in many PR systems?

RIF-PRD defines one single object element and one or more ordered pairs of slotKey-slotValue elements. In addition, Frame elements can be nested,abstract class for actions: ACTION, that is, a complete Frame elementis allowed asrealised by five concrete constructs:

• the content of a slotValue element, instead of a TERM : this allows to represent in a compact way object-attribute-value triples where the value is itself qualified. Finally,Assert, Remove and Update constructs are associated with an ATOMIC that represents the syntaxtarget of the Frame element allowseponym actions;
• the object element to contain a Member or a Subclass element instead ofExecute construct is associated with a TERM : this permits the direct representation in RIF of compact atomic statementsthat contain classification information aboutidentifies the subject individual within object-attribute-value triples. Inoperation to be executed, and zero or more TERMs that form, the Frame is about the individual represented by the content of the object sub-element withinrepresent the Member element orarguments with which the subClass sub-element withinoperation is to be executed;
• the Subclass element. AsAssign construct is associated with a consequence, theFrame element, in its most complete form, contains: a single object element,that is required. The content ofrepresents the target object element canand slot, as well as the new value to be assigned.

Editor's Note: Should other actions be considered in RIF-PRD? Esp., do we need some basic programatic constructs, such as a construct ofloop?

2.2.1 ACTION

The CONDITIONACTION class of constructs is used to represent any truth-valued statement, atomic or not, that is allowedthe individual actions in the conditionaction part of a production rule covered by RIF-PRD.represented in rule languages covered by RIF-PRD, the truth valuesRIF-PRD.

This version of statements can be "true" or "false": that is, CONDITION s can only represent boolean statements. Dialects extendingRIF-PRD may support additional truth values. XML syntax.covers five ACTIONs: Assert, Remove, Update, Execute and Assign.

As an abstract class, CONDITIONACTION is not associated with specific XML markup in RIF-PRD instance documents. It is specified in the normative schema as a substitution group.

***Editor's Note: ...Substitution group or another construct, depending on how we handle extensibility in the XML schema.

     ***[  ATOMICAssert |  AndRemove  |  OrUpdate  |  NafExecute  |  ExistsAssign ]

*** Difference wrt RIF-BLD: a RIF-PRD without a construct for closed-world negation would not make mush sense; hence the addition of2.2.1.1 Assert

The Naf construct wrt BLD. ThisAssert construct is specificused to PRD. *** Presentation syntax. CONDITION ::= ATOMIC | And | Or | Naf | Exists 2.1.3.1. ATOMIC A CONDITION can be a singlerepresent actions that result in asserting an atomic statement.

See specification of [ ATOMIC], above. 2.1.3.2. And A CONDITION can representThe conjunction of zero of more statements, each of them represented byAssert element has one target sub-element that contains a CONDITION . This is represented byconstruct from the And construct. XML syntax.ATOMIC group, which represents the And element contains zero or more formula elements, each containing an element ofatomic statement to be asserted on implementing the CONDITION group. <And> <formula> CONDITION </formula>* </And> Presentation syntax. And ::= 'AND ( ' CONDITION* ' ) ' Informal semantics.action. The AndEqual construct is used to represent a statements that is true iff: it is an empty conjunction, represented bynot allowed as the target of an emptyAssert

Editor's Note: Are there other restrictions on the kind of ATOMIC that can be Assert-ed? Shall we allow Member and element;Subclass ATOMICs to be Assert-ed? Or allshould we make no restriction: the sub-statements represented byassertion of an Equal might be well-formed, after all; its assertion might have unexpected results, but is that RIF's concern?

Editor's Note: Issues: ATOMIC might not be the CONDITION s inright way to represent the And 's formula sub-elements are true. 2.1.3.3. Ortarget anyway: what about the case where a CONDITION can representnew individual has to be created? Use, by convention, the disjunction of zero of more statements, eachassertion of them represented byan anonymous frame (that is, a CONDITION . Thisframe where the object is represented bythe name of a class, not an individual)?

Editor's Note: Or construct. XML syntax.remove the Or element contains zero or more formula elements, each containingAssert construct and interpret an element ofATOMIC as an ACTION as an assert? That would improve PRD/BLD/Core compatibility at the CONDITION group. <Or> <formula> CONDITION </formula>* </Or> Presentation syntax. Or ::= ' OR ( ' CONDITION* ' ) ' Informal semantics.synatctic level. What would be the Ordrawbacks?

    <Assert>
       <target> ATOMIC </target>
    </Assert>

2.2.1.2 Remove

The Remove construct is used to represent a statements that is true iff: it is not an empty disjunction,actions that is, if it has at least one non-empty formula sub-element; and at least one of the sub-statements represented by the CONDITION sresult in negating an atomic statement.

The Or 's formula sub-elements is true. 2.1.3.4. Naf A CONDITION can represent the non-monotonic negation of a statement, itself represented by a CONDITION : this is represenetd by the NAF construct. XML syntax. The NafRemove element contains exactlyhas one formula element. The formula elementtarget sub-element that contains an element ofa construct from the CONDITION group,ATOMIC group that represents the negated statement. <Naf> <formula> CONDITION </formula> </Naf> *** Difference wrt RIF-BLD: that construct is specificatomic statement to RIF-PRD. *** Presentation syntax. Naf ::= ' NAF ( ' CONDITION ' ) ' Informal semantics.be removed on implementing the Naf construct is used to represent statements thataction.

Editor's Note: Are true iff the statement represented bythere any restriction on the CONDITION formula is not known tokind of ATOMIC that can be true. ***removed? E.g. what is the truth value of an empty NAF? *** 2.1.3.5. Exists *** is this needed in additionwould it mean to 2.1.4.2.? (Gary) ***remove an Equal? Should we allow a CONDITION canMember or a Subclass ATOMIC to be Remove-ed?

Editor's Note: Issue: ATOMIC might not be the right way to represent an existentially quantified formula ofthe CONDITION class: this is represented bytarget anyway: e.g. how to Remove an individual (if empty Frames are not allowed)?

    <Remove>
       <target> ATOMIC </target>
    </Remove>

Editor's Note: Issue: How to remove multiple facts at once? E.g. Remove-ing an individual: use empty frames (if allowed) as a convention?

Example. The Exists construct. *** Difference wrt RIF-BLD:example below shows the notionRIF XML representation of an aggregate variable is rather basic in production rule languages, much more than in logic languages, I guess. Therefore, due toaction that updates the different semantics of Var in BLD and PRD, aggregation should be at least considered for inclusion in PRD, even if it is not in BLD. See alsochicken-potato ownership table by removing the remark underpredicate that states that the specification of Exists, inchicken denoted by variable ?c owns the QUANTIFICATION Section, below. *** In addition of being a CONDITION , Exists is also a concrete construct ofpotato denoted by variable ?p. The QUANTIFICATION class. Itpredicate is further specified under that class, below. 2.1.4. QUANTIFICATIONrepresented as in example XX.