RIF Basic Logic Dialect

W3C Editor's Draft 22 September18 December 2008

This version:

http://www.w3.org/2005/rules/wg/draft/ED-rif-bld-20080922/http://www.w3.org/2005/rules/wg/draft/ED-rif-bld-20081218/

Latest editor's draft:

http://www.w3.org/2005/rules/wg/draft/rif-bld/

Previous version:

http://www.w3.org/2005/rules/wg/draft/ED-rif-bld-20080730/http://www.w3.org/2005/rules/wg/draft/ED-rif-bld-20080922/ (color-coded diff)

Editors:

Harold Boley, National Research Council, Canada

Michael Kifer, State University of New York at Stony Brook, USA

This document is also available in these non-normative formats: PDF version.

---

Copyright © 2008 W3C^® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.

Abstract

Status of this Document

May Be Superseded

This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.

SetIntermediate Snapshot Only (Not For Review)

No Endorsement

Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.

Patents

This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.

This specification develops RIF-BLD (the Basic Logic Dialect of the Rule Interchange Format). From a theoretical perspective, RIF-BLD corresponds to the language of definite Horn rules with equality and a standard first-order semantics [CL73]. Syntactically, RIF-BLD hashas a number of extensions to support features such as objects and frames as in F-logic [KLW95], internationalized resource identifiers (or IRIs, defined by [RFC-3987]) as identifiers for concepts, and XML Schema datatypes [XML-SCHEMA2]. In addition, RIF RDF and OWL Compatibility [RIF-RDF+OWL] defines the syntax and semantics of integrated RIF-BLD/RDF and RIF-BLD/OWL languages. These features make RIF-BLD a Web-aware language. However, it should be kept in mind that RIF is designed to enable interoperability among rule languages in general, and its uses are not limited to the Web.

While rule interchange (and not, e.g. execution) is the principle design goal for RIF-BLD, the design clearly indicates a decision to avoid solving the (probably impossible) problem of rule interchange in general. Instead, the design of RIF reflects the rationale of identifying specific kinds of rules within existing rule systems, called RIF dialects, that can be translated into other rule systems without changing their meaning. RIF-BLD is just the first in a series of such dialects. It is not expected that most rule systems will be able to translate all their rules into RIF-BLD, rather it is expected that only certain kinds of rules will be translatable. Since there are many existing rule languages with useful features that are not supported in RIF-BLD, it is expected that RIF-BLD translators will not translate rules that use such features. This could drive the design of "BLD-specific" rule sets in which rules are specifically written by the implementor to be within the BLD dialect and thus be portabile between many rule system implementations.

Among its many influences, RIF shares certain characteristics with ISO Common Logic (CL) [ISO-CL], itself an evolution of KIF [KIF] and Conceptual Graphs [CG]. Like CL, RIF employs XML as its primary normative syntax, uses IRIs as identifiers, specifies integrated RIF-BLD/RDF and RIF-BLD/OWL languages for Semantic Web Compatibility [RIF-RDF+OWL], and provides a rich set of datatypes and builtins that are designed to be well aligned with web-aware rule system implementations [RIF-DTB]. Unlike CL, RIF-BLD was designed to be a simple dialect with limited expressiveness that lies within the intersection of first-order and logic-programming systems. This is why RIF-BLD does not support negation. More generally, RIF-BLD is part of a numberconsistent array of extensions to support features such as objectsRIF rule dialects, which encompasses both logic rules -- including a variety of rule languages based on non-monotonic theories -- and framesproduction rules, as in F-logic [ KLW95 ], internationalized resource identifiers (or IRIs,defined byin [ RFC-3987 ])RIF-PRD]. CL, on the other hand, is strictly first-order; it does not account for non-monotonic semantics (e.g. negation as identifiersfailure, defaults, priorities, etc.). For concepts,rule interchange between CL and XML Schema datatypes [ XML-SCHEMA2 ]. In addition,RIF dialects, partial RIF-CL mappings will eventually be defined.

RIF-BLD also bears some similarity to SPARQL, in particular with respect to RDF and OWLCompatibility [RIF-RDF+OWL ] defines]. As with the syntax and semanticswell-known correspondence between a fragment of integrated RIF-BLD/RDFSQL and RIF-BLD/OWL languages. These features make RIF-BLD a Web-aware language. However, it shouldDatalog, SPARQL can be keptpartially mapped to Datalog (and thus to RIF-BLD), see [AP07] and [AG08] for details. A full mapping of SPARQL would need constructs beyond RIF-BLD, such as non-monotonic negation. Likewise, not all of SPARQL's FILTER functions are expressible in mind that RIFRIF-DTB built-in predicates. Not all of RIF-BLD is designed to enable interoperability among rule languagesexpresible in general, and its usesSPARQL either, for instance recursive rules over RDF Data are not limited to the Web.expressible as SPARQL CONSTRUCT statements.

RIF-BLD is defined in two different ways -- both normative:

• As a direct specification, independently of the RIF framework for logic dialects [RIF-FLD], for the benefit of those who desire a direct path to RIF-BLD, e.g., as prospective implementers, and are not interested in extensibility issues. This version of the RIF-BLD specification is given first.
• As a specialization of the RIF framework for logic dialects [RIF-FLD], which is part of the RIF extensibility framework. Building on RIF-FLD, this version of the RIF-BLD specification is comparatively short and is presented in Section RIF-BLD as a Specialization of the RIF Framework at the end of this document. This is intended for the reader who is already familiar with RIF-FLD and does not need to go through the much longer direct specification of RIF-BLD. This section is also useful for dialect designers, as it is a concrete example of how a non-trivial RIF dialect can be derived from the RIF framework for logic dialects.

Logic-based RIF dialects that specialize or extend RIF-BLD in accordance with the RIF framework for logic dialects [RIF-FLD] will be developed in other specifications by the RIF working group.

To give a preview, here is a simple complete RIF-BLD example deriving a ternary relation from its inverse.

Example 1 (An introductory RIF-BLD example).

A rule can be written in English to derive the buy relationships (rather than store them) from the sell relationships that are stored as facts (e.g., as exemplified by the English statement below):

• A buyer buys an item from a seller if the seller sells the item to the buyer.
• John sells LeRif to Mary.

The fact Mary buys LeRif from John can be logically derived by a modus ponens argument. Assuming Web IRIs for the predicates buy and sell, as well as for the individuals John, Mary, and LeRif, the above English text can be represented in RIF-BLD Presentation Syntax as follows.

Document(
  Prefix(cpt http://example.com/concepts#)
  Prefix(ppl http://example.com/people#)
  Prefix(bks http://example.com/books#)

  Group
  (
    Forall ?Buyer ?Item ?Seller (
        cpt:buy(?Buyer ?Item ?Seller) :- cpt:sell(?Seller ?Item ?Buyer)
    )
 
    cpt:sell(ppl:John bks:LeRif ppl:Mary)
  )
)

For the interchange of such rule (and fact) documents, an equivalent RIF-BLD XML Syntax is given in this specification. To formalize their meaning, a RIF-BLD Semantics is specified.

This normative section specifies the syntax of RIF-BLD directly, without relying on [RIF-FLD]. We define both the presentation syntax (below) and an XML syntax in Section XML Serialization Syntax for RIF-BLD. The presentation syntax is normative, but is not intended to be a concrete syntax for RIF-BLD. It is defined in "mathematical English,""mathematical English," a special form of English for communicating mathematical definitions, examples, etc. The presentation syntax deliberately leaves out details such as the delimiters of the various syntactic components, escape symbols, parenthesizing, precedence of operators, and the like. Since RIF is an interchange format, it uses XML as its concrete syntax and RIF-BLD conformance is described in terms of semantics-preserving transformations.

Note to the reader: this section depends on Section Constants, Symbol Spaces, and Datatypes of [RIF-DTB].

Constants are written as "literal"^^symspace"literal"^^symspace, where literal is a sequence of Unicode characters and symspace is an identifier for a symbol space. Symbol spaces are defined in Section Constants and Symbol Spaces of [RIF-DTB].

The symbols =, #, and ## are used in formulas that define equality, class membership, and subclass relationships. The symbol -> is used in terms that have named arguments and in frame formulas. The symbol External indicates that an atomic formula or a function term is defined externally (e.g., a built-in) and the symbols Prefix and Base enable abridged representations of IRIs [RFC-3987].

The symbol Document is used to specify RIF-BLD documents, the symbol Import is an import directive, and the symbol Group is used to organize RIF-BLD formulas into collections.   ☐  ☐

The language of RIF-BLD is the set of formulas constructed using the above alphabet according to the rules given below.

1. Constants and variables. If t ∈∈ Const or t ∈∈ Var then t is a simple term.
2. Positional terms. If t ∈∈ Const and t₁, ..., t_n, n≥0n≥0, are base terms then t(t₁ ... t_n) is a positional term.
3. Terms with named arguments. A term with named arguments is of the form t(s₁->v₁ ... s_n->v_n), where n≥0n≥0, t ∈∈ Const and v₁, ..., v_n are base terms and s₁, ..., s_n are pairwise distinct symbols from the set ArgNames.

   The constant t here represents a predicate or a function; s₁, ..., s_n represent argument names; and v₁, ..., v_n represent argument values. The argument names, s₁, ..., s_n, are required to be pairwise distinct. Terms with named arguments are like positional terms except that the arguments are named and their order is immaterial. Note that a term of the form f() is, trivially, both a positional term and a term with named arguments.

4. Equality terms. t = st = s is an equality term, if t and s are base terms.
5. Class membership terms (or just membership terms). t#s is a membership term if t and s are base terms.
6. Subclass terms. t##s is a subclass term if t and s are base terms.
7. Frame terms. t[p₁->v₁ ... p_n->v_n] is a frame term (or simply a frame) if t, p₁, ..., p_n, v₁, ..., v_n, n ≥≥ 0, are base terms.

   Membership, subclass, and frame terms are used to describe objects and class hierarchies.

8. Externally defined terms. If t is a positional, named-argument, or a frame term then External(t) is an externally defined term.

   Such terms are used for representing built-in functions and predicates as well as "procedurally attached""procedurally attached" terms or predicates, which might exist in various rule-based systems, but are not specified by RIF.

   Note that not only predicates and functions, but also frame terms can be externally defined. Therefore, external information sources can be modeled in an object-oriented way via frames. For instance, External("http://example.com/acme"^^rif:iri["http://example.com/mycompany/president"^^rif:iri(?Year) -> ?Pres])External("http://example.com/acme"^^rif:iri["http://example.com/mycompany/president"^^rif:iri(?Year) -> ?Pres]) could be a representation of an externally defined method "http://example.com/mycompany/president"^^rif:iri"http://example.com/mycompany/president"^^rif:iri in an external object "http://example.com/acme"^^rif:iri"http://example.com/acme"^^rif:iri.   ☐  ☐

   Feature At Risk #1: External frames

   Note: This feature is "at risk""at risk" and may be removed from this specification based on feedback. Please send feedback to public-rif-comments@w3.org.

Observe that the argument names of frame terms, p₁, ..., p_n, are base terms and so, as a special case, can be variables. In contrast, terms with named arguments can use only the symbols from ArgNames to represent their argument names. They cannot be constants from Const or variables from Var. The reason for this restriction has to do with the complexity of unification, which is used by several inference mechanisms of first-order logic.

RIF-BLD distinguishes certain subsets of the set Const of symbols, including the subset of predicate symbols and function symbols. Section Well-formed Formulas gives more details, but we do not need those details yet.

Any term (positional or with named arguments) of the form p(...), where p is a predicate symbol, is also an atomic formula. Equality, membership, subclass, and frame terms are also atomic formulas. An externally defined term of the form External(φ)External(φ), where φφ is an atomic formula, is also an atomic formula, called an externally defined atomic formula.

Note that simple terms (constants and variables) are not formulas.

More general formulas are constructed out of the atomic formulas with the help of logical connectives.

Definition (Formula). A formula can have several different forms and is defined as follows:

1. Atomic: If φφ is an atomic formula then it is also a formula.
2. Condition formula: A condition formula is either an atomic formula or a formula that has one of the following forms:
   • Conjunction: If φφ₁, ..., φφ_n, n ≥≥ 0, are condition formulas then so is And(φAnd(φ₁ ... φφ_n), called a conjunctive formula. As a special case, And() is allowed and is treated as a tautology, i.e., a formula that is always true.
   • Disjunction: If φφ₁, ..., φφ_n, n ≥≥ 0, are condition formulas then so is Or(φOr(φ₁ ... φφ_n), called a disjunctive formula. As a special case, Or() is permitted and is treated as a contradiction, i.e., a formula that is always false.
   • Existentials: If φφ is a condition formula and ?V₁, ..., ?V_n, n>0, are variables then Exists ?VExists ?V₁ ... ?V... ?V_n (φ)(φ) is an existential formula.

   Condition formulas are intended to be used inside the premises of rules. Next we define the notion of RIF-BLD rules, sets of rules, and RIF documents.

3. Rule implication: φ :- ψφ :- ψ is a formula, called rule implication, if:
   • φφ is an atomic formula or a conjunction of atomic formulas,
   • ψψ is a condition formula, and
   • none of the atomic formulas in φφ is an externally defined term (i.e., a term of the form External(...)). (Note: external terms can occur in the arguments of atomic formulas in the head.)rule conclusion.)

   Feature At Risk #2: Equality in the rule conclusion ( φφ in the above)

   Note: This feature is "at risk""at risk" and may be removed from this specification based on feedback. Please send feedback to public-rif-comments@w3.org.

4. Universal rule: If φφ is a rule implication and ?V₁, ..., ?V_n, n>0, are variables then Forall ?VForall ?V₁ ... ?V... ?V_n (φ)(φ) is a formula, called a universal rule. It is required that all the free variables in φφ occur among the variables ?V₁ ... ?V... ?V_n in the quantification part. An occurrence of a variable ?v is free in φφ if it is not inside a substring of the form Q ?v (ψ)Q ?v (ψ) of φφ, where Q is a quantifier (Forall or Exists) and ψψ is a formula. Universal rules will also be referred to as RIF-BLD rules.
5. Universal fact: If φφ is an atomic formula then Forall ?VForall ?V₁ ... ?V... ?V_n (φ)(φ) is a formula, called a universal fact, provided that all the free variables in φφ occur among the variables ?V₁ ... ?V... ?V_n.

   Universal facts are often considered to be rules without premises (or having true as their premises).

6. Group: If φφ₁, ..., φφ_n are RIF-BLD rules, universal facts, variable-free rule implications, variable-free atomic formulas, or group formulas then Group(φGroup(φ₁ ... φφ_n) is a group formula.

   Group formulas are used to represent sets of rules and facts. Note that some of the φφ_i's can be group formulas themselves, which means that groups can be nested.

7. Document: An expression of the form Document(directive₁ ... directive_n Γ)Γ) is a RIF-BLD document formula (or simply a document formula), if
   • ΓΓ is an optional group formula.formula; it is called the group formula associated with the document.
   • directive₁, ..., directive_n is an optional sequence of directives. A directive can be a base directive, a prefix directive or an import directive.
     • A base directive has the form Base(iri), where iri is a unicode string in the form of an IRI [RFC-3987].

       The Base directive defines a syntactic shortcut for expanding relative IRIs into full IRIs, as described in Section Constants and Symbol Spaces of [RIF-DTB].

     • A prefix directive has the form Prefix(p v), where p is an alphanumeric string that serves as the prefix name and v is an expansion for p -- a string that forms an IRI. (An alphanumeric string is a sequence of ASCII characters, where each character is a letter, a digit, or an underscore "_","_", and the first character is a letter.)

       Like the Base directive, the Prefix directives define shorthands to allow more concise representation of constants that come from the symbol space rif:iri (we will call such constants rif:iri constants). This mechanism is explained in [RIF-DTB], Section Constants and Symbol Spaces.

     • An import directive can have one of these two forms: Import(t) or Import(t p). Here t is a rif:iri constant and p is a term. The constant t indicates the location of another document to be imported and p is called the profile of import.

       Section Direct Specification of RIF-BLD Semantics of this document defines the semantics for the directive Import(t) only. The two-argument directive, Import(t p), is intended for importing non-RIF-BLD documents, such as rules from other RIF dialects, RDF data, or OWL ontologies. The profile, p, indicates what kind of entity is being imported and under what semantics (for instance, the various RDF entailment regimes have different profiles). The semantics of Import(t p) (for various p) are expected to be given by other specifications on a case-by-case basis. For instance, [RIF-RDF+OWL] defines the semantics for the profiles that are recommended for importing RDF and OWL.

     A document formula can contain at most one Base directive. The Base directive, if present, must be first, followed by any number of Prefix directives, followed by any number of Import directives.

In the definition of a formula, the component formulas φφ, φφ_i, ψψ_i, and ΓΓ are said to be subformulas of the respective formulas (condition, rule, group, etc.) that are built using these components.   ☐  ☐

RIF-BLD allows every term and formula (including terms and formulas that occur inside other terms and formulas) to be optionally preceded by an annotation of the form (* id φφ *), where id is a rif:iri constant and φφ is a frame formula or a conjunction of frame formulas. Both items inside the annotation are optional. The id part represents the identifier of the term or formula to which the annotation is attached and φφ is the metadata part of the annotation. RIF-BLD does not impose any restrictions on φφ apart from what is stated above. This means that it may include variables, function symbols, constants from the symbol space rif:local (often referred to as local or rif:local constants), and so on.

Document formulas with and without annotations will be referred to as RIF-BLD documents.

A convention is used to avoid a syntactic ambiguity in the above definition. For instance, in (* id φφ *) t[w -> v] the metadata annotation could be attributed to the term t or to the entire frame t[w -> v]. The convention in RIF-BLD is that the above annotation is considered to be syntactically attached to the entire frame. Yet, since φφ can be a conjunction, some conjuncts can be used to provide metadata targeted to the object part, t, of the frame. For instance, (* And(_foo[meta_for_frame->"thisAnd(_foo[meta_for_frame->"this is an annotation for the entire frame"] _bar[meta_for_object->"thisframe"] _bar[meta_for_object->"this is an annotation for t" meta_for_property->"thist" meta_for_property->"this is an annotation for w"]w"] *) t[w -> v]. Generally, the convention associates each annotation to the largest term or formula it precedes.

We suggest to use Dublin Core, RDFS, and OWL properties for metadata, along the lines of Section 7.1 of [OWL-Reference]-- specifically owl:versionInfo, rdfs:label, rdfs:comment, rdfs:seeAlso, rdfs:isDefinedBy, dc:creator, dc:description, dc:date, and foaf:maker.

• If s occurs as a predicate in an atomic subformula of the form s(...) with arity αα then s occurs in the context of a predicate symbol with arity αα.
• If s occurs as a function symbol in a term (not subformula) of the form s(...) with arity αα then s occurs in the context of a function symbol with arity αα.
• If s occurs as a predicate in an atomic subformula External(s(...)) with arity αα then s occurs in the context of an external predicate symbol with arity αα.
• If s occurs as a function in a term (not subformula) External(s(...)) with arity αα then s occurs in the context of an external function symbol with arity αexternal function symbol with arity α.
• If s occurs in any other context (in a frame: s[...], ...[s->...], or ...[...->s]; or in a positional/named argument term: p(...s...), q(...->s...)), it is said to occur as an individual.   ☐  ☐

Definition (Imported document). Let ΔΔ be a document formula and Import(t) be one of its import directives, where t is a rif:iri constant that identifies another document formula, Δ'Δ'. We say that Δ'Δ' is directly imported into ΔΔ.

A document formula Δ'Δ' is said to be imported into ΔΔ if it is either directly imported into ΔΔ or it is imported (directly or not) into some other formula that is directly imported into ΔΔ.        ☐

The above definition deals only with one-argument import directives, since only such directives can be used to import other RIF-BLD documents. Two-argument import directives are provided to enable import of other types of documents, and their semantics are supposed to be covered by other specifications, such as [RIF-RDF+OWL].

Definition (Well-formed formula). A formula φφ is well-formed iff:

• every constant symbol (whether coming from the symbol space rif:local or not) mentioned in φφ occurs in exactly one context.
• if φφ is a document formula and Δ'Δ'₁, ..., Δ'Δ'_k are all of its imported documents, then every non-rif:local constant symbol mentioned in φφ or any of the imported Δ'Δ'_is must occur in exactly one context (in all of the Δ'Δ'_is).
• whenever a formula contains a term or a subformula of the form External(t), t must be an instance of a schema in the coherent set of external schemas (Section Schemas for Externally Defined Terms of [RIF-DTB]) associated with the language of RIF-BLD.
•   ☐if t is an instance of a schema in the coherent set of external schemas associated with the language then t can occur only as External(t), i.e., as an external term or atomic formula.   ☐

Definition (Language of RIF-BLD). The language of RIF-BLD consists of the set of all well-formed formulas and is determined by:

• the alphabet of the language and
• a set of coherent external schemas, which determine the available built-ins and other externally defined predicates and functions.   ☐  ☐

• The syntax of first-order logic is not context-free, so EBNF cannot capture the syntax of RIF-BLD precisely. For instance, it cannot capture the section on well-formedness conditions, i.e., the requirement that each symbol in RIF-BLD can occur in at most one context. As a result, the EBNF grammar defines a strict superset of RIF-BLD: not all formulas that are derivable using the EBNF grammar are well-formed formulas in RIF-BLD.
• The EBNF grammar does not address all details of how constants (defined in [RIF-DTB]) and variables are represented, and it is not sufficiently precise about the delimiters and escape symbols. White space is informally used as a delimiter, and is implied in productions that use Kleene star. For instance, TERM* is to be understood as TERM TERM ... TERMTERM TERM ... TERM, where each space abstracts from one or more blanks, tabs, newlines, etc. This is so because RIF's presentation syntax is a tool for specifying the semantics and for illustration of the main RIF concepts through examples. It is not intended as a concrete syntax for a rule language. RIF defines a concrete syntax only for exchanging rules, and that syntax is XML-based, obtained as a refinement and serialization of the presentation syntax.
• For all the above reasons, the EBNF grammar is not normative. Recall, however, that the RIF-BLD presentation syntax, as specified in mathematical English, is normative.

The EBNF for the RIF-BLD presentation syntax is given as follows, showing the entire (top-down) context of its three parts for rules, conditions, and annotations.

Rule Language:

  Document       ::= IRIMETA? 'Document' '(' Base? Prefix* Import* Group? ')'
  Base           ::= 'Base' '(' IRI ')'
  Prefix         ::= 'Prefix' '(' Name IRI ')'
  Import         ::= IRIMETA? 'Import' '(' IRICONST PROFILE? ')'
  Group          ::= IRIMETA? 'Group' '(' (RULE | Group)* ')'
  RULE           ::= (IRIMETA? 'Forall' Var+ '(' CLAUSE ')') | CLAUSE
  CLAUSE         ::= Implies | ATOMIC
  Implies        ::= IRIMETA? (ATOMIC | 'And' '(' ATOMIC* ')') ':-' FORMULA
  PROFILE        ::= TERM

Condition Language:

  FORMULA        ::= IRIMETA? 'And' '(' FORMULA* ')' |
                     IRIMETA? 'Or' '(' FORMULA* ')' |
                     IRIMETA? 'Exists' Var+ '(' FORMULA ')' |
                     ATOMIC |
                     IRIMETA? 'External' '(' Atom | Frame ')'
  ATOMIC         ::= IRIMETA? (Atom | Equal | Member | Subclass | Frame)
  Atom           ::= UNITERM
  UNITERM        ::= Const '(' (TERM* | (Name '->' TERM)*) ')'
  Equal          ::= TERM '=' TERM
  Member         ::= TERM '#' TERM
  Subclass       ::= TERM '##' TERM
  Frame          ::= TERM '[' (TERM '->' TERM)* ']'
  TERM           ::= IRIMETA? (Const | Var | Expr | 'External' '(' Expr ')')
  Expr           ::= UNITERM
  Const          ::=  '"''"' UNICODESTRING  '"^^''"^^' SYMSPACE | CONSTSHORT
  Name           ::= UNICODESTRING
  Var            ::= '?' UNICODESTRING
  SYMSPACE       ::= ANGLEBRACKIRI | CURIE

Annotations:

  IRIMETA        ::= '(*' IRICONST? (Frame | 'And' '(' Frame* ')')? '*)'

The following subsections explain and exemplify these parts, starting with the basic language of positive conditions.

The Condition Language represents formulas that can be used in the premises of RIF-BLD rules (also called rule bodies). The EBNF grammar for a superset of the RIF-BLD condition language is shown in the above conditions part.

The production rule for the non-terminal FORMULA represents RIF condition formulas (defined earlier). The connectives And and Or define conjunctions and disjunctions of conditions, respectively. Exists introduces existentially quantified variables. Here Var+ stands for the list of variables that are free in FORMULA. RIF-BLD conditions permit only existential variables. A RIF-BLD FORMULA can also be an ATOMIC term, i.e. an Atom, External Atom, Equal, Member, Subclass, or Frame. A TERM can be a constant, variable, Expr, or External Expr.

The RIF-BLD presentation syntax does not commit to any particular vocabulary and permits arbitrary Unicode strings in constant symbols, argument names, and variables. Constant symbols can have this form: "UNICODESTRING"^^SYMSPACE"UNICODESTRING"^^SYMSPACE, where SYMSPACE is an ANGLEBRACKIRI or CURIE that represents the identifier of the symbol space of the constant, and UNICODESTRING is a Unicode string from the lexical space of that symbol space. ANGLEBRACKIRI and CURIE are defined in Section Shortcuts for Constants in RIF's Presentation Syntax of [RIF-DTB]. Constant symbols can also have several shortcut forms, which are represented by the non-terminal CONSTSHORT. These shortcuts are also defined in the same section of [RIF-DTB]. One of them is the CURIE shortcut, which is extensively used in the examples in this document. Names are Unicode character sequences. Variables are composed of UNICODESTRING symbols prefixed with a ?-sign.

Equality, membership, and subclass terms are self-explanatory. An Atom and Expr (expression) can either be positional or with named arguments. A frame term is a term composed of an object Id and a collection of attribute-value pairs. An External(Atom) is a call to an externally defined predicate; External(Frame) is a call to an externally defined frame. Likewise, External(Expr) is a call to an externally defined function.

Example 2 (RIF-BLD conditions).

This example shows conditions that are composed of atoms, expressions, frames, and existentials. In frame formulas variables are shown in the positions of object Ids, object properties, and property values. For brevity, we use the shortcut notation prefix:suffix for constant symbols, which is understood as a shorthand for an IRI obtained by concatenation of the prefix definition and suffix. Thus, if bks is a prefix that expands into http://example.com/books# then bks:LeRif is an abbreviation for "http://example.com/books#LeRif"^^rif:iri"http://example.com/books#LeRif"^^rif:iri. This and other shortcuts are defined in [RIF-DTB].

Prefix(bks  http://example.com/books#)
Prefix(auth http://example.com/authors#)
Prefix(cpt  http://example.com/concepts#)

Positional terms:
  
  cpt:book(auth:rifwg bks:LeRif)
  Exists ?X (cpt:book(?X bks:LeRif))

Terms with named arguments:

  cpt:book(cpt:author->auth:rifwg  cpt:title->bks:LeRif)
  Exists ?X (cpt:book(cpt:author->?X cpt:title->bks:LeRif))

Frames:

  bks:wd1[cpt:author->auth:rifwg cpt:title->bks:LeRif]
  Exists ?X (bks:wd2[cpt:author->?X  cpt:title->bks:LeRif])
  Exists ?X (And (bks:wd2#cpt:book  bks:wd2[cpt:author->?X  cpt:title->bks:LeRif]))
  Exists ?I ?X (?I[cpt:author->?X  cpt:title->bks:LeRif])
  Exists ?I ?X (And (?I#cpt:book ?I[cpt:author->?X  cpt:title->bks:LeRif]))
  Exists ?S (bks:wd2[cpt:author->auth:rifwg ?S->bks:LeRif])
  Exists ?X ?S (bks:wd2[cpt:author->?X ?S->bks:LeRif])
  Exists ?I ?X ?S (And (?I#cpt:book  ?I[author->?X ?S->bks:LeRif]))

The presentation syntax for RIF-BLD rules is based on the syntax in Section EBNF for RIF-BLD Condition Language with the productions shown in the above rules part.

A RIF-BLD Document consists of an optional Base, followed by any number of Prefixes, followed by any number of Imports, followed by an optional Group. Base and Prefix serve as shortcut mechanisms for IRIs. IRI has the form of an internationalized resource identifier as defined by [RFC-3987]. An Import indicates the location of a document to be imported and an optional profile. A RIF-BLD Group is a collection of any number of RULE elements along with any number of nested Groups.

Rules are generated using CLAUSE elements. The RULE production has two alternatives:

• In the first, a CLAUSE is in the scope of the Forall quantifier. In that case, all variables mentioned in CLAUSE are required to also appear among the variables in the Var+ sequence.
• In the second alternative, CLAUSE appears on its own. In that case, CLAUSE cannot have variables.

Var, ATOMIC, and FORMULA were defined as part of the syntax for positive conditions in Section EBNF for RIF-BLD Condition Language. In the CLAUSE production, an ATOMIC is what is usually called a fact. An Implies rule can have an ATOMIC or a conjunction of ATOMIC elements as its conclusion; it has a FORMULA as its premise. Note that, by a definition in Section Formulas, formulas that query externally defined atoms (i.e., formulas of the form External(Atom(...))) are not allowed in the conclusion part of a rule (ATOMIC does not expand to External).

Example 3 (RIF-BLD rules).

This example shows a business rule borrowed from the document RIF Use Cases and Requirements:

• If an item is perishable and it is delivered to John more than 10 days after the scheduled delivery date then the item will be rejected by him.

As before, for better readability we use the compact URI notation defined in [RIF-DTB], Section Constants and Symbol Spaces. Again, prefix directives are assumed in the preamble to the document. Then, two versions of the main part of the document are given.

Prefix(ppl  http://example.com/people#)
Prefix(cpt  http://example.com/concepts#)
Prefix(func http://www.w3.org/2007/rif-builtin-function#)
Prefix(pred http://www.w3.org/2007/rif-builtin-predicate#)

a. Universal form:

   Forall ?item ?deliverydate ?scheduledate ?diffduration ?diffdays (
        cpt:reject(ppl:John ?item) :-
            And(cpt:perishable(?item)
                cpt:delivered(?item ?deliverydate ppl:John)
                cpt:scheduled(?item ?scheduledate)
                ?diffduration = External(func:subtract-dateTimes(?deliverydate ?scheduledate))
                ?diffdays = External(func:days-from-duration(?diffduration))
                External(pred:numeric-greater-than(?diffdays 10)))
   )

b. Universal-existential form:

   Forall ?item (
        cpt:reject(ppl:John ?item ) :-
            Exists ?deliverydate ?scheduledate ?diffduration ?diffdays (
                 And(cpt:perishable(?item)
                     cpt:delivered(?item ?deliverydate ppl:John)
                     cpt:scheduled(?item ?scheduledate)
                     ?diffduration = External(func:subtract-dateTimes(?deliverydate ?scheduledate))
                     ?diffdays = External(func:days-from-duration(?diffduration))
                     External(pred:numeric-greater-than(?diffdays 10)))
            )
   )

The EBNF grammar production for RIF-BLD annotations is shown in the above annotations part.

As explained in Section RIF-BLD Annotations in the Presentation Syntax, RIF-BLD formulas and terms can be prefixed with optional annotations, IRIMETA, for identification and metadata. IRIMETA is represented using (*...*)-brackets that contain an optional rif:iri constant, IRICONST, as identifier followed by an optional Frame or conjunction of Frames as metadata.

An IRICONST is the special case of a Const with the symbol space rif:iri, again permitting the shortcut forms defined in [RIF-DTB]. One such specialization is '"''"' IRI '"^^''"^^' 'rif:iri' from the Const production, where IRI is a sequence of Unicode characters that forms an internationalized resource identifier as defined by [RFC-3987].

Example 4 (A RIF-BLD document containing an annotated group).

This example shows a complete document containing a group formula that consists of two RIF-BLD rules. The first of these rules is copied from Example 3a. The group is annotated with an IRI identifier and frame-represented Dublin Core metadata.

Document(
  Prefix(ppl  http://example.com/people#)
  Prefix(cpt  http://example.com/concepts#)
  Prefix(dc   http://purl.org/dc/terms/)
  Prefix(func http://www.w3.org/2007/rif-builtin-function#)
  Prefix(pred http://www.w3.org/2007/rif-builtin-predicate#)
  Prefix(xs   http://www.w3.org/2001/XMLSchema#)
  
  (*  "http://sample.org"^^rif:iri"http://sample.org"^^rif:iri pd[dc:publisher ->  "http://www.w3.org/"^^rif:iri"http://www.w3.org/"^^rif:iri
                                     dc:date ->  "2008-04-04"^^xs:date]"2008-04-04"^^xs:date] *)
  Group
  (
    Forall ?item ?deliverydate ?scheduledate ?diffduration ?diffdays (
        cpt:reject(ppl:John ?item) :-
            And(cpt:perishable(?item)
                cpt:delivered(?item ?deliverydate ppl:John)
                cpt:scheduled(?item ?scheduledate)
                ?diffduration = External(func:subtract-dateTimes(?deliverydate ?scheduledate))
                ?diffdays = External(func:days-from-duration(?diffduration))
                External(pred:numeric-greater-than(?diffdays 10)))
    )
 
    Forall ?item (
        cpt:reject(ppl:Fred ?item) :- cpt:unsolicited(?item)
    )
  )
)

This normative section specifies the semantics of RIF-BLD directly, without relying on [RIF-FLD].

Recall that the presentation syntax of RIF-BLD allows shorthand notation, which is specified via the Prefix and Base directives, and various shortcuts for integers, strings, and rif:local symbols. The semantics, below, is described using the full syntax, i.e., we assume that all shortcuts have already been expanded as defined in [RIF-DTB], Section Constants and Symbol Spaces.

The key concept in a model-theoretic semantics of a logic language is the notion of a semantic structure [Enderton01, Mendelson97]. The definition, below, is a bit more general than necessary. This is done in order to better see the connection with the semantics of the RIF framework described in [RIF-FLD].

Definition (Semantic structure). A semantic structure, I, is a tuple of the form <TV, DTS, D, D_ind, D_func, I_C, I_V, I_F, I_frame, I_NF, I_sub, I_isa, I₌, I_external, I_truth>. Here D is a non-empty set of elements called the domain of I, and D_ind, D_func are nonempty subsets of D. D_ind is used to interpret the elements of Const that are individuals and D_func is used to interpret the elements of Const that are function symbols. As before, Const denotes the set of all constant symbols and Var the set of all variable symbols. TV denotes the set of truth values that the semantic structure uses and DTS is a set of identifiers for primitive datatypes (please refer to Section Datatypes of [RIF-DTB] for the semantics of datatypes).

The other components of I are total mappings defined as follows:

1. I_C maps Const to D.

   This mapping interprets constant symbols. In addition:

   • If a constant, c  ∈  ∈ Const, is an individual then it is required that I_C(c ) ∈ ) ∈ D_ind.
   • If c  ∈  ∈ Const, is a function symbol (positional or with named arguments) then it is required that I_C(c ) ∈ ) ∈ D_func.
2. I_V maps Var to D_ind.

   This mapping interprets variable symbols.

3. I_F maps D to functions D*_ind →→ D (here D*_ind is a set of all sequences of any finite length over the domain D_ind).

   This mapping interprets positional terms. In addition:

   • If d ∈∈ D_func then I_F(d) must be a function D*_ind →→ D_ind.
   • This means that when a function symbol is applied to arguments that are individual objects then the result is also an individual object.
4. I_NF maps D to the set of total functions of the form SetOfFiniteSets(ArgNames ×× D_ind) →→ D.

   This mapping interprets function symbols with named arguments. In addition:

   • If d ∈∈ D_func then I_NF(d) must be a function SetOfFiniteSets(ArgNames ×× D_ind) →→ D_ind.
   • This is analogous to the interpretation of positional terms with two differences:
     • Each pair <s,v> ∈∈ ArgNames ×× D_ind represents an argument/value pair instead of just a value in the case of a positional term.
     • The arguments of a term with named arguments constitute a finite set of argument/value pairs rather than a finite ordered sequence of simple elements. So, the order of the arguments does not matter.
5. I_frame maps D_ind to total functions of the form SetOfFiniteBags(D_ind ×× D_ind) →→ D.

   This mapping interprets frame terms. An argument, d ∈∈ D_ind, to I_frame represents an object and the finite bag {<a1,v1>, ..., <ak,vk>} represents a bag of attribute-value pairs for d. We will see shortly how I_frame is used to determine the truth valuation of frame terms.

   Bags (multi-sets) are used here because the order of the attribute/value pairs in a frame is immaterial and pairs may repeat: o[a->b a->b]o[a->b a->b]. Such repetitions arise naturally when variables are instantiated with constants. For instance, o[?A->?B ?C->?D]o[?A->?B ?C->?D] becomes o[a->b a->b]o[a->b a->b] if variables ?A and ?C are instantiated with the symbol a and ?B, ?D with b. (We shall see later that o[a->b a->b]o[a->b a->b] is equivalent to o[a->b].)

6. I_sub gives meaning to the subclass relationship. It is a mapping of the form D_ind ×× D_ind →→ D.

   The operator ## is required to be transitive, i.e., c1 ## c2c1 ## c2 and c2 ## c3c2 ## c3 must imply c1 ## c3c1 ## c3. This is ensured by a restriction in Section Interpretation of Formulas.

7. I_isa gives meaning to class membership. It is a mapping of the form D_ind ×× D_ind →→ D.

   The relationships # and ## are required to have the usual property that all members of a subclass are also members of the superclass, i.e., o # clo # cl and cl ## sclcl ## scl must imply o # sclo # scl. This is ensured by a restriction in Section Interpretation of Formulas.

8. I₌ is a mapping of the form D_ind ×× D_ind →→ D.

   It gives meaning to the equality operator.

9. I_truth is a mapping of the form D →→ TV.

   It is used to define truth valuation for formulas.

10. I_external is a mapping from the coherent set of schemas for externally defined functions to total functions D* →→ D. For each external schema σσ = (?X₁ ... ?X... ?X_n ; τ); τ) in the coherent set of external schemas associated with the language, I_external( σσ) is a function of the form Dⁿ →→ D.

    For every external schema, σσ, associated with the language, I_external( σσ) is assumed to be specified externally in some document (hence the name external schema). In particular, if σσ is a schema of a RIF built-in predicate or function, I_external( σσ) is specified in [RIF-DTB] so that:

    • If σσ is a schema of a built-in function then I_external( σσ) must be the function defined in the aforesaid document.
    • If σσ is a schema of a built-in predicate then I_truth οο (I_external( σσ)) (the composition of I_truth and I_external( σσ), a truth-valued function) must be as specified in [RIF-DTB].

For convenience, we also define the following mapping I from terms to D:

• I(k) = I_C(k), if k is a symbol in Const
• I(?v) = I_V(?v), if ?v is a variable in Var
• I(f(t₁ ... t_n)) = I_F(I(f))(I(t₁),...,I(t_n))
• I(f(s₁->v₁ ... s_n->v_n)) = I_NF(I(f))({<s₁,I(v₁)>,...,<s_n,I(v_n)>})

  Here we use {...} to denote a set of argument/value pairs.

• I(o[a₁->v₁ ... a_k->v_k]) = I_frame(I(o))({<I(a₁),I(v₁)>, ..., <I(a_n),I(v_n)>})

  Here {...} denotes a bag of attribute/value pairs. Jumping ahead, we note that duplicate elements in such a bag do not affect the value of I_frame(I(o)) -- see Section Interpretation of Non-document Formulas. For instance, I(o[a->b a->b]) = I(o[a->b]).

• I(c1##c2) = I_sub(I(c1), I(c2))
• I(o#c) = I_isa(I(o), I(c))
• I(x=y) = I₌(I(x), I(y))
• I(External(t)) = I_external( σσ)(I(s₁), ..., I(s_n)), if t is an instance of the external schema σσ = (?X₁ ... ?X... ?X_n ; τ); τ) by substitution ?X₁/s₁ ... ?X... ?X_n/s₁.

  Note that, by definition, External(t) is well-formed only if t is an instance of an external schema. Furthermore, by the definition of coherent sets of external schemas, t can be an instance of at most one such schema, so I(External(t)) is well-defined.

The effect of datatypes. The set DTS must include the datatypes described in Section Primitive Datatypes of [RIF-DTB].

The datatype identifiers in DTS impose the following restrictions. Given dt ∈∈ DTS, let LS_dt denote the lexical space of dt, VS_dt denote its value space, and L_dt: LS_dt →→ VS_dt the lexical-to-value-space mapping (for the definitions of these concepts, see Section Primitive Datatypes of [RIF-DTB]. Then the following must hold:

• VS_dt ⊆⊆ D_ind; and
• For each constant "lit"^^dt"lit"^^dt such that lit ∈∈ LS_dt, I_C( "lit"^^dt"lit"^^dt) = L_dt(lit).

That is, I_C must map the constants of a datatype dt in accordance with L_dt.

RIF-BLD does not impose restrictions on I_C for constants in symbol spaces that are not datatypes included in DTS.   ☐  ☐

1. Positional atomic formulas: TVal_I(r(t₁ ... t_n)) = I_truth(I(r(t₁ ... t_n)))
2. Atomic formulas with named arguments: TVal_I(p(s₁->v₁ ... s_k->v_k)) = I_truth(I(p(s₁->v₁ ... s_k->v_k))).
3. Equality: TVal_I( x = yx = y) = I_truth(I( x = yx = y)).
   • To ensure that equality has precisely the expected properties, it is required that:
     • I_truth(I( x = yx = y)) = t if and only ifI(x) = I(y) and that I_truth(I( x = yx = y)) = f otherwise.
   • This is tantamount to saying that TVal_I( x = yx = y) = t if and only if I(x) = I(y).
4. Subclass: TVal_I( sc ## clsc ## cl) = I_truth(I( sc ## clsc ## cl)).

   To ensure that the operator ## is transitive, i.e., c1 ## c2c1 ## c2 and c2 ## c3c2 ## c3 imply c1 ## c3c1 ## c3, the following is required:

   • For all c1, c2, c3 ∈∈ D,    if TVal_I( c1 ## c2c1 ## c2) = TVal_I( c2 ## c3c2 ## c3) = t    then TVal_I( c1 ## c3c1 ## c3) = t.
5. Membership: TVal_I( o # clo # cl) = I_truth(I( o # clo # cl)).

   To ensure that all members of a subclass are also members of the superclass, i.e., o # clo # cl and cl ## sclcl ## scl implies o # sclo # scl, the following is required:

   • For all o, cl, scl ∈∈ D,    if TVal_I( o # clo # cl) = TVal_I( cl ## sclcl ## scl) = t    then    TVal_I( o # sclo # scl) = t.
6. Frame: TVal_I(o[a₁->v₁ ... a_k->v_k]) = I_truth(I(o[a₁->v₁ ... a_k->v_k])).

   Since the bag of attribute/value pairs represents the conjunctions of all the pairs, the following is required, if k > 0:

   • TVal_I(o[a₁->v₁ ... a_k->v_k]) = t if and only if TVal_I(o[a₁->v₁]) = ... = TVal_I(o[a_k->v_k]) = t.
7. Externally defined atomic formula: TVal_I(External(t)) = I_truth(I_external( σσ)(I(s₁), ..., I(s_n))), if t is an atomic formula that is an instance of the external schema σσ = (?X₁ ... ?X... ?X_n; τ)τ) by substitution ?X₁/s₁ ... ?X... ?X_n/s₁.

   Note that, by definition, External(t) is well-formed only if t is an instance of an external schema. Furthermore, by the definition of coherent sets of external schemas, t can be an instance of at most one such schema, so I(External(t)) is well-defined.

8. Conjunction: TVal_I(And(c₁ ... c_n)) = t if and only if TVal_I(c₁) = ... = TVal_I(c_n) = t. Otherwise, TVal_I(And(c₁ ... c_n)) = f.

   The empty conjunction is treated as a tautology, so TVal_I(And()) = t.

9. Disjunction: TVal_I(Or(c₁ ... c_n)) = f if and only if TVal_I(c₁) = ... = TVal_I(c_n) = f. Otherwise, TVal_I(Or(c₁ ... c_n)) = t.

   The empty disjunction is treated as a contradiction, so TVal_I(Or()) = f.

10. Quantification:
    • TVal_I( Exists ?vExists ?v₁ ... ?v... ?v_n (φ)(φ)) = t if and only if for some I*, described below, TVal_I*( φφ) = t.
    • TVal_I( Forall ?vForall ?v₁ ... ?v... ?v_n (φ))(φ)) = t if and only if for every I*, described below, TVal_I*( φφ) = t.

    Here I* is a semantic structure of the form <TV, DTS, D, D_ind, D_func, I_C, I*_V, I_F, I_frame, I_NF, I_sub, I_isa, I₌, I_external, I_truth>, which is exactly like I, except that the mapping I*_V, is used instead of I_V.    I*_V is defined to coincide with I_V on all variables except, possibly, on ?v₁,...,?v_n.

11. Rule implication:
    • TVal_I(conclusion  :- :- condition) = t, if either TVal_I(conclusion)=t or TVal_I(condition)=f.
    • TVal_I(conclusion  :- :- condition) = f    otherwise.
12. Groups of rules:

    If ΓΓ is a group formula of the form Group(φGroup(φ₁ ... φφ_n) then

    • TVal_I( ΓΓ) = t if and only if TVal_I( φφ₁) = t, ..., TVal_I( φφ_n) = t.
    • TVal_I( ΓΓ) = f    otherwise.

    This means that a group of rules is treated as a conjunction.   ☐  ☐

Definition (Semantic multi-structure). A semantic multi-structure is a set {I ^Δφ₁, ..., I ^Δφ_n }, n>0, where I Δ 1, ..., I Δ n are...} of semantic structures adorned with document formulas.distinct RIF-BLD formulas φ₁, ..., φ_n. These structures must be identical in all respects except that the mappings I_C ^Δφ₁, ..., I_C ^Δφ_n might, ... may differ on the constants in Const that belong to the rif:local symbol space. The above set is allowed to have at most one semantic structure with the same adornment.        ☐

With the help of semantic multi-structuresWe can now explaindefine the semantics of RIF documents.

Definition (Truth valuation of adocument formula).formulas). Let ΔΔ be a document formula and let ΔΔ₁, ..., ΔΔ_k be all the RIF-BLD document formulas that are imported (directly or indirectly, according to Definition Imported document) into ΔΔ. Let ΓΓ, ΓΓ₁, ..., ΓΓ_k denote the respective group formulas associated with these documents. If any of these Γ i is missing (which is a possibility, since every part of a document is optional), assume that it is a tautology, such as a = a , so that every TVal function maps such a Γ i to the truth value t .Let I = {I ^ΔΔ, I ^ΔΔ₁, ..., I ^ΔΔ_k, ...} be a semantic multi-structure that contains semantic structures adorned with at least the documents ΔΔ, ΔΔ₁, ..., ΔΔ_k. Then we define:

• TVal_I(Δ) = t if and only if TVal_I^Δ(Γ) = TVal_I^Δ1(Γ₁) = ... = TVal_I^Δk(Γ_k) = t.         ☐

Note that this definition considers only those document formulas that are reachable via the one-argument import directives. Two argument import directives are not covered here. Their semantics is defined by the document RIF RDF and OWL Compatibility [RIF-RDF+OWL].

Also note that some of the Γ_i above may be missing since all parts in a document formula are optional. In this case, we assume that Γ_i is a tautology, such as a = a, and every TVal function maps such a Γ_i to the truth value t.

ThenFor non-document formulas, we define:extend TVal_I( Δφ) = t if and onlyfrom regular semantic structures to multi-structures as follows: if I is a multi-structure that has a component structure I^φ adorned with φ then TVal_I Δ( Γφ) = TVal_{I ^{Δ 1φ}}( Γ 1 ) = ... =φ). Otherwise, TVal_I Δ k( Γ kφ) = t . Note that this definition considers only those document formulas that are reachable via the one-argument import directives. Two argument import directives are not covered here. Their semanticsis defined by the document RIF RDF and OWL Compatibility [ RIF-RDF+OWL ].         ☐undefined.

The above definitions make the intent behind the rif:local constants clear: occurrences of such constants in different documents can be interpreted differently even if they have the same name. Therefore, each document can choose the names for the rif:local constants freely and without regard to the names of such constants used in the imported documents.

• a normative mapping from the RIF-BLD presentation syntax to XML (Section Mapping from the Presentation Syntax to the XML Syntax), and
• a normative XML Schema for the XML syntax (Appendix XML Schema for BLD).

Recall that the syntax of RIF-BLD is not context-free and thus cannot be fully captured by EBNF or XML Schema. Still, validity with respect to XML Schema can be a useful test. To reflect this state of affairs, we define two notions of syntactic correctness. The weaker notion checks correctness only with respect to XML Schema, while the stricter notion represents "true""true" syntactic correctness.

Definition (Valid BLD document in XML syntax). A valid BLD document in the XML syntax is an XML document that is valid with respect to the XML schema in Appendix XML Schema for BLD.   ☐  ☐

Definition (Conformant BLD document in XML syntax). A conformant BLD document in the XML syntax is a valid BLD document in the XML syntax that is the image of a well-formed RIF-BLD document in the presentation syntax (see Definition Well-formed formula in Section Formulas) under the presentation-to-XML syntax mapping χχ_bld defined in Section Mapping from the Presentation Syntax to the XML Syntax.   ☐  ☐

The XML serialization for RIF-BLD is alternating or fully striped [ANF01]. A fully striped serialization views XML documents as objects and divides all XML tags into class descriptors, called type tags, and property descriptors, called role tags [TRT03]. We follow the tradition of using capitalized names for type tags and lowercase names for role tags.

The all-uppercase classes in the presentation syntax, such as FORMULA, become XML Schema groups in Appendix XML Schema for BLD. They are not visible in instance markup. The other classes as well as non-terminals and symbols (such as Exists or =) become XML elements with optional attributes, as shown below.

RIF-BLD uses [XML1.0] for its XML syntax.

XML serialization of RIF-BLD in Section EBNF for RIF-BLD Condition Language uses the following elements.

- And       (conjunction)
- Or        (disjunction)
- Exists    (quantified formula for 'Exists', containing declare and formula roles)
- declare   (declare role, containing a Var)
- formula   (formula role, containing a FORMULA)
- Atom      (atom formula, positional or with named arguments)
- External  (external call, containing a content role)
- content   (content role, containing an Atom, for predicates, or Expr, for functions)
- Member    (member formula)
- Subclass  (subclass formula)
- Frame     (Frame formula)
- object    (Member/Frame role, containing a TERM or an object description)
- op        (Atom/Expr role for predicates/functions as operations)
- args      (Atom/Expr positional arguments role, with fixed 'ordered' attribute, containing n TERMs)
- instance  (Member instance role)
- class     (Member class role)
- sub       (Subclass sub-class role)
- super     (Subclass super-class role)
- slot      (Atom/Expr or Frame slot role, with fixed 'ordered' attribute, containing a Name or TERM followed by a TERM)
- Equal     (prefix version of term equation '=')
- Expr      (expression formula, positional or with named arguments)
- left      (Equal left-hand side role)
- right     (Equal right-hand side role)
- Const     (individual, function, or predicate symbol, with optional 'type' attribute)
- Name      (name of named argument)
- Var       (logic variable)
   
- id        (identifier role, containing IRICONST)
- meta      (meta role, containing metadata as a Frame or Frame conjunction)

The id and meta elements, which are expansions of the IRIMETA element, can occur optionally as the initial children of any Class element.

For the XML Schema definition of the RIF-BLD condition language see Appendix XML Schema for BLD.

The XML syntax for symbol spaces uses the type attribute associated with the XML element Const. For instance, a literal in the xs:dateTime datatype is represented as <Const type="&xs;dateTime">2007-11-23T03:55:44-02:30</Const><Const type="&xs;dateTime">2007-11-23T03:55:44-02:30</Const>. RIF-BLD also uses the ordered attribute to indicate that the children of args and slot elements are ordered.

Example 5 (A RIF condition and its XML serialization).

This example illustrates XML serialization for RIF conditions. As before, the compact URI notation is used for better readability. Assume that the following prefix directives are found in the preamble to the document:

Prefix(bks    http://example.com/books#)
Prefix(cpt    http://example.com/concepts#)
Prefix(curr   http://example.com/currencies#)
Prefix(rif    http://www.w3.org/2007/rif#)
Prefix(xs     http://www.w3.org/2001/XMLSchema#)

RIF condition

   And (Exists ?Buyer (cpt:purchase(?Buyer ?Seller
                                    cpt:book(?Author bks:LeRif)
                                    curr:USD(49)))
        ?Seller=?Author )

XML serialization

   <And>
     <formula>
       <Exists>
         <declare><Var>Buyer</Var></declare>
         <formula>
           <Atom>
             <op><Const  type="&rif;iri">&cpt;purchase</Const></op>type="&rif;iri">&cpt;purchase</Const></op>
             <args  ordered="yes">ordered="yes">
               <Var>Buyer</Var>
               <Var>Seller</Var>
               <Expr>
                 <op><Const  type="&rif;iri">&cpt;book</Const></op>type="&rif;iri">&cpt;book</Const></op>
                 <args  ordered="yes">ordered="yes">
                   <Var>Author</Var>
                   <Const  type="&rif;iri">&bks;LeRif</Const>type="&rif;iri">&bks;LeRif</Const>
                 </args>
               </Expr>
               <Expr>
                 <op><Const  type="&rif;iri">&curr;USD</Const></op>type="&rif;iri">&curr;USD</Const></op>
                 <args  ordered="yes"><Const type="&xs;integer">49</Const></args>ordered="yes"><Const type="&xs;integer">49</Const></args>
               </Expr>
             </args>
           </Atom>
         </formula>
       </Exists>
     </formula>
     <formula>
       <Equal>
         <left><Var>Seller</Var></left>
         <right><Var>Author</Var></right>
       </Equal>
     </formula>
   </And>

Example 6 (A RIF condition with named arguments and its XML serialization).

This example illustrates XML serialization of RIF conditions that involve terms with named arguments. As in Example 5, we assume the following prefix directives:

Prefix(bks    http://example.com/books#)
Prefix(cpt    http://example.com/concepts#)
Prefix(curr   http://example.com/currencies#)
Prefix(rif    http://www.w3.org/2007/rif#)
Prefix(xs     http://www.w3.org/2001/XMLSchema#)

RIF condition:

   And (Exists ?Buyer ?P (
                 And (?P#cpt:purchase
                      ?P[cpt:buyer->?Buyer
                         cpt:seller->?Seller
                         cpt:item->cpt:book(cpt:author->?Author cpt:title->bks:LeRif)
                         cpt:price->49
                         cpt:currency->curr:USD]))
        ?Seller=?Author)


XML serialization:

   <And>
     <formula>
       <Exists>
         <declare><Var>Buyer</Var></declare>
         <declare><Var>P</Var></declare>
         <formula>
           <And>
             <formula>
               <Member>
                 <instance><Var>P</Var></instance>
                 <class><Const  type="&rif;iri">&cpt;purchase</Const></class>type="&rif;iri">&cpt;purchase</Const></class>
               </Member>
             </formula>
             <formula>
               <Frame>
                 <object>
                   <Var>P</Var>
                 </object>
                 <slot  ordered="yes">ordered="yes">
                   <Const  type="&rif;iri">&cpt;buyer</Const>type="&rif;iri">&cpt;buyer</Const>
                   <Var>Buyer</Var>
                 </slot>
                 <slot  ordered="yes">ordered="yes">
                   <Const  type="&rif;iri">&cpt;seller</Const>type="&rif;iri">&cpt;seller</Const>
                   <Var>Seller</Var>
                 </slot>
                 <slot  ordered="yes">ordered="yes">
                   <Const  type="&rif;iri">&cpt;item</Const>type="&rif;iri">&cpt;item</Const>
                   <Expr>
                     <op><Const  type="&rif;iri">&cpt;book</Const></op>type="&rif;iri">&cpt;book</Const></op>
                     <slot  ordered="yes">ordered="yes">
                       <Name>&cpt;author</Name>
                       <Var>Author</Var>
                     </slot>
                     <slot  ordered="yes">ordered="yes">
                       <Name>&cpt;title</Name>
                       <Const  type="&rif;iri">&bks;LeRif</Const>type="&rif;iri">&bks;LeRif</Const>
                     </slot>
                   </Expr>
                 </slot>
                 <slot  ordered="yes">ordered="yes">
                   <Const  type="&rif;iri">&cpt;price</Const>type="&rif;iri">&cpt;price</Const>
                   <Const  type="&xs;integer">49</Const>type="&xs;integer">49</Const>
                 </slot>
                 <slot  ordered="yes">ordered="yes">
                   <Const  type="&rif;iri">&cpt;currency</Const>type="&rif;iri">&cpt;currency</Const>
                   <Const  type="&rif;iri">&curr;USD</Const>type="&rif;iri">&curr;USD</Const>
                 </slot>
               </Frame>
             </formula>
           </And>
         </formula>
       </Exists>
     </formula>
     <formula>
       <Equal>
         <left><Var>Seller</Var></left>
         <right><Var>Author</Var></right>
       </Equal>
     </formula>
   </And>

We now extend the set of RIF-BLD serialization elements from Section XML for RIF-BLD Condition Language by including rules, along with their enclosing groups and documents, as described in Section EBNF for RIF-BLD Rule Language. The extended set includes the tags listed below. While there is a RIF-BLD element tag for the Import directive, there are none for the Prefix and Base directives: they are handled as discussed in Section Mapping of the RIF-BLD Rule Language.

- Document  (document, containing optional directive and payload roles)
- directive (directive role, containing Import)
- payload   (payload role, containing Group)
- Import    (importation, containing location and optional profile)
- location  (location role, containing IRICONST)
- profile   (profile role, containing PROFILE)
- Group     (nested collection of sentences)
- sentence  (sentence role, containing RULE or Group)
- Forall    (quantified formula for 'Forall', containing declare and formula roles)
- Implies   (implication, containing if and then roles)
- if        (antecedent role, containing FORMULA)
- then      (consequent role, containing ATOMIC or conjunction of ATOMICs)

The XML Schema Definition of RIF-BLD is given in Appendix XML Schema for BLD.

Example 7 (Serializing a RIF-BLD document containing an annotated group).

This example shows a serialization for the document from Example 4. For convenience, the document is reproduced at the top and then is followed by its serialization.

Presentation syntax:

Document(
  Prefix(ppl  http://example.com/people#)
  Prefix(cpt  http://example.com/concepts#)
  Prefix(dc   http://purl.org/dc/terms/)
  Prefix(rif  http://www.w3.org/2007/rif#)
  Prefix(func http://www.w3.org/2007/rif-builtin-function#)
  Prefix(pred http://www.w3.org/2007/rif-builtin-predicate#)
  Prefix(xs   http://www.w3.org/2001/XMLSchema#)
  
  (*  "http://sample.org"^^rif:iri"http://sample.org"^^rif:iri pd[dc:publisher ->  "http://www.w3.org/"^^rif:iri"http://www.w3.org/"^^rif:iri
                                     dc:date ->  "2008-04-04"^^xs:date]"2008-04-04"^^xs:date] *)
  Group
  (
    Forall ?item ?deliverydate ?scheduledate ?diffduration ?diffdays (
        cpt:reject(ppl:John ?item) :-
            And(cpt:perishable(?item)
                cpt:delivered(?item ?deliverydate ppl:John)
                cpt:scheduled(?item ?scheduledate)
                ?diffduration = External(func:subtract-dateTimes(?deliverydate ?scheduledate))
                ?diffdays = External(func:days-from-duration(?diffduration))
                External(pred:numeric-greater-than(?diffdays 10)))
    )
 
    Forall ?item (
        cpt:reject(ppl:Fred ?item) :- cpt:unsolicited(?item)
    )
  )
)


XML syntax:

<!DOCTYPE Document [
  <!ENTITY ppl   "http://example.com/people#">"http://example.com/people#">
  <!ENTITY cpt   "http://example.com/concepts#">"http://example.com/concepts#">
  <!ENTITY dc    "http://purl.org/dc/terms/">"http://purl.org/dc/terms/">
  <!ENTITY rif   "http://www.w3.org/2007/rif#">"http://www.w3.org/2007/rif#">
  <!ENTITY func  "http://www.w3.org/2007/rif-builtin-function#">"http://www.w3.org/2007/rif-builtin-function#">
  <!ENTITY pred  "http://www.w3.org/2007/rif-builtin-predicate#">"http://www.w3.org/2007/rif-builtin-predicate#">
  <!ENTITY xs    "http://www.w3.org/2001/XMLSchema#">"http://www.w3.org/2001/XMLSchema#">
]>

<Document 
     xmlns="http://www.w3.org/2007/rif#" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xs="http://www.w3.org/2001/XMLSchema#">xmlns="http://www.w3.org/2007/rif#"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:xs="http://www.w3.org/2001/XMLSchema#">
  <payload>
   <Group>
    <id>
      <Const  type="&rif;iri">http://sample.org</Const>type="&rif;iri">http://sample.org</Const>
    </id>
    <meta>
      <Frame>
        <object>
          <Const  type="&rif;local">pd</Const>type="&rif;local">pd</Const>
        </object>
        <slot  ordered="yes">ordered="yes">
          <Const  type="&rif;iri">&dc;publisher</Const>type="&rif;iri">&dc;publisher</Const>
          <Const  type="&rif;iri">http://www.w3.org/</Const>type="&rif;iri">http://www.w3.org/</Const>
        </slot>
        <slot  ordered="yes">ordered="yes">
          <Const  type="&rif;iri">&dc;date</Const>type="&rif;iri">&dc;date</Const>
          <Const  type="&xs;date">2008-04-04</Const>type="&xs;date">2008-04-04</Const>
        </slot>
      </Frame>
    </meta>
    <sentence>
     <Forall>
       <declare><Var>item</Var></declare>
       <declare><Var>deliverydate</Var></declare>
       <declare><Var>scheduledate</Var></declare>
       <declare><Var>diffduration</Var></declare>
       <declare><Var>diffdays</Var></declare>
       <formula>
         <Implies>
           <if>
             <And>
               <formula>
                 <Atom>
                   <op><Const  type="&rif;iri">&cpt;perishable</Const></op>type="&rif;iri">&cpt;perishable</Const></op>
                   <args  ordered="yes"><Var>item</Var></args>ordered="yes"><Var>item</Var></args>
                 </Atom>
               </formula>
               <formula>
                 <Atom>
                   <op><Const  type="&rif;iri">&cpt;delivered</Const></op>type="&rif;iri">&cpt;delivered</Const></op>
                   <args  ordered="yes">ordered="yes">
                     <Var>item</Var>
                     <Var>deliverydate</Var>
                     <Const  type="&rif;iri">&ppl;John</Const>type="&rif;iri">&ppl;John</Const>
                   </args>
                 </Atom>
               </formula>
               <formula>
                 <Atom>
                   <op><Const  type="&rif;iri">&cpt;scheduled</Const></op>type="&rif;iri">&cpt;scheduled</Const></op>
                   <args  ordered="yes">ordered="yes">
                     <Var>item</Var>
                     <Var>scheduledate</Var>
                   </args>
                 </Atom>
               </formula>
               <formula>
                 <Equal>
                   <left><Var>diffduration</Var></left>
                   <right>
                     <External>
                       <content>
                         <Expr>
                           <op><Const  type="&rif;iri">&func;subtract-dateTimes</Const></op>type="&rif;iri">&func;subtract-dateTimes</Const></op>
                           <args  ordered="yes">ordered="yes">
                             <Var>deliverydate</Var>
                             <Var>scheduledate</Var>
                           </args>
                         </Expr>
                       </content>
                     </External>
                   </right>
                 </Equal>
               </formula>
               <formula>
                 <Equal>
                   <left><Var>diffdays</Var></left>
                   <right>
                     <External>
                       <content>
                         <Expr>
                           <op><Const  type="&rif;iri">&func;days-from-duration</Const></op>type="&rif;iri">&func;days-from-duration</Const></op>
                           <args  ordered="yes">ordered="yes">
                             <Var>diffduration</Var>
                           </args>
                         </Expr>
                       </content>
                     </External>
                   </right>
                 </Equal>
               </formula>
               <formula>
                 <External>
                   <content>
                     <Atom>
                       <op><Const  type="&rif;iri">&pred;numeric-greater-than</Const></op>type="&rif;iri">&pred;numeric-greater-than</Const></op>
                       <args  ordered="yes">ordered="yes">
                         <Var>diffdays</Var>
                         <Const  type="&xs;integer">10</Const>type="&xs;integer">10</Const>
                       </args>
                     </Atom>
                   </content>
                 </External>
               </formula>
             </And>
           </if>
           <then>
             <Atom>
               <op><Const  type="&rif;iri">&cpt;reject</Const></op>type="&rif;iri">&cpt;reject</Const></op>
               <args  ordered="yes">ordered="yes">
                 <Const  type="&rif;iri">&ppl;John</Const>type="&rif;iri">&ppl;John</Const>
                 <Var>item</Var>
               </args>
             </Atom>
           </then>
         </Implies>
       </formula>
     </Forall>
    </sentence>
    <sentence>
     <Forall>
       <declare><Var>item</Var></declare>
       <formula>
         <Implies>
           <if>
             <Atom>
               <op><Const  type="&rif;iri">&cpt;unsolicited</Const></op>type="&rif;iri">&cpt;unsolicited</Const></op>
               <args  ordered="yes"><Var>item</Var></args>ordered="yes"><Var>item</Var></args>
             </Atom>
           </if>
           <then>
             <Atom>
               <op><Const  type="&rif;iri">&cpt;reject</Const></op>type="&rif;iri">&cpt;reject</Const></op>
               <args  ordered="yes">ordered="yes">
                 <Const  type="&rif;iri">&ppl;Fred</Const>type="&rif;iri">&ppl;Fred</Const>
                 <Var>item</Var>
               </args>
             </Atom>
           </then>
         </Implies>
       </formula>
     </Forall>
    </sentence>
   </Group>
  </payload>
 </Document>

The χχ_bld mapping from the presentation syntax to the XML syntax of the RIF-BLD Condition Language is specified by the table below. Each row indicates a translation χχ_bld(Presentation) = XML. Since the presentation syntax of RIF-BLD is context sensitive, the mapping must differentiate between the terms that occur in the position of the individuals and the terms that occur as atomic formulas. To this end, in the translation table, the positional and named argument terms that occur in the context of atomic formulas are denoted by the expressions of the form pred(...) and the terms that occur as individuals are denoted by expressions of the form func(...). In the table, each metavariable for an (unnamed) positional argument_i is assumed to be instantiated to values unequal to the instantiations of named arguments unicodestring_j -> filler_j. Regarding the last but first row, we assume that shortcuts for constants [RIF-DTB] have already been expanded to their full form ( "..."^^"..."^^symspace).

And (
  conjunct1
  . . .
  conjunctn
    )

<And>
  <formula> χχbld(conjunct1)</formula>
   . . .
  <formula> χχbld(conjunctn)</formula>
</And>

Or (
  disjunct1
  . . .
  disjunctn
   )

<Or>
  <formula> χχbld(disjunct1)</formula>
   . . .
  <formula> χχbld(disjunctn)</formula>
</Or>

Exists
  variable1
  . . .
  variablen (
              bodypremise
            )

<Exists>
  <declare> χχbld(variable1)</declare>
   . . .
  <declare> χχbld(variablen)</declare>
  <formula> χχbld( bodypremise)</formula>
</Exists>

External (
  atomframexpr
         )

<External>
  <content> χχbld(atomframexpr)</content>
</External>

pred (
  argument1
  . . .
  argumentn
     )

<Atom>
  <op> χχbld(pred)</op>
  <args  ordered="yes"> χordered="yes">
    χbld(argument1)
    . . .
     χχbld(argumentn)
  </args>
</Atom>

func (
  argument1
  . . .
  argumentn
     )

<Expr>
  <op> χχbld(func)</op>
  <args  ordered="yes"> χordered="yes">
    χbld(argument1)
    . . .
     χχbld(argumentn)
  </args>
</Expr>

pred (
  unicodestring1 -> filler1
  . . .
  unicodestringn -> fillern
     )

<Atom>
  <op> χχbld(pred)</op>
  <slot  ordered="yes">ordered="yes">
    <Name>unicodestring1</Name>
     χχbld(filler1)
  </slot>
   . . .
  <slot  ordered="yes">ordered="yes">
    <Name>unicodestringn</Name>
     χχbld(fillern)
  </slot>
</Atom>

func (
  unicodestring1 -> filler1
  . . .
  unicodestringn -> fillern
     )

<Expr>
  <op> χχbld(func)</op>
  <slot  ordered="yes">ordered="yes">
    <Name>unicodestring1</Name>
     χχbld(filler1)
  </slot>
   . . .
  <slot  ordered="yes">ordered="yes">
    <Name>unicodestringn</Name>
     χχbld(fillern)
  </slot>
</Expr>

inst [
  key1 -> filler1
  . . .
  keyn -> fillern
     ]

<Frame>
  <object> χχbld(inst)</object>
  <slot  ordered="yes"> χordered="yes">
    χbld(key1)
     χχbld(filler1)
  </slot>
   . . .
  <slot  ordered="yes"> χordered="yes">
    χbld(keyn)
     χχbld(fillern)
  </slot>
</Frame>

inst # class

<Member>
  <instance> χχbld(inst)</instance>
  <class> χχbld(class)</class>
</Member>

sub ## super

<Subclass>
  <sub> χχbld(sub)</sub>
  <super> χχbld(super)</super>
</Subclass>

left = right

<Equal>
  <left> χχbld(left)</left>
  <right> χχbld(right)</right>
</Equal>

 ""unicodestring "^^"^^symspace

<Const  type="type="symspace ">">unicodestring</Const>

?unicodestring

<Var>unicodestring</Var>

The χχ_bld mapping from the presentation syntax to the XML syntax of the RIF-BLD Rule Language is specified by the table below. It extends the translation table of Section Translation of RIF-BLD Condition Language. While the Import directive is handled by the presentation-to-XML syntax mapping, the Prefix and Base directives are not. Instead, these directives should be handled by expanding the associated shortcuts (compact URIs). Namely, a prefix name declared in a Prefix directive is expanded into the associated IRI, while relative IRIs are completed using the IRI declared in the Base directive. The mapping χχ_bld applies only to such expanded documents. RIF-BLD also allows other treatments of Prefix and Base provided that they produce equivalent XML documents. One such treatment is employed in the examples in this document, especially Example 7. It replaces prefix names with definitions of XML entities as follows. Each Prefix declaration becomes an ENTITY declaration [XML1.0] within a DOCTYPE DTD attached to the RIF-BLD Document. The Base directive is mapped to the xml:base attribute [XML-Base] in the XML Document tag. Compact URIs of the form prefix:suffix are then mapped to &prefix;suffix.

Document(
  Import(loc1 prfl1?)
   . . .
  Import(locn prfln?)
  group
        )

<Document>
  <directive>
    <Import>
      <location> χχbld(loc1)</location>
      <profile> χχbld(prfl1)</profile>?
    </Import>
  </directive>
   . . .
  <directive>
    <Import>
      <location> χχbld(locn)</location>
      <profile> χχbld(prfln)</profile>?
    </Import>
  </directive>
  <payload> χχbld(group)</payload>
</Document>

Group(
  clause1
   . . .
  clausen
     )

<Group>
  <sentence> χχbld(clause1)</sentence>
   . . .
  <sentence> χχbld(clausen)</sentence>
</Group>

Forall
  variable1
   . . .
  variablen (
             rule
            )

<Forall>
  <declare> χχbld(variable1)</declare>
   . . .
  <declare> χχbld(variablen)</declare>
  <formula> χχbld(rule)</formula>
</Forall>

conclusion :- condition

<Implies>
  <if> χχbld(condition)</if>
  <then> χχbld(conclusion)</then>
</Implies>

The χχ_bld mapping from RIF-BLD annotations in the presentation syntax to the XML syntax is specified by the table below. It extends the translation tables of Sections Translation of RIF-BLD Condition Language and Translation of RIF-BLD Rule Language. The metavariable Typetag in the presentation and XML syntaxes stands for any of the class names And, Or, External, Document, or Group, and Quantifier for Exists or Forall. The dollar sign, $, stands for any of the binary infix operator names #, ##, =, or :-, while Binop stands for their respective class names Member, Subclass, Equal, or Implies. Again, each metavariable for an (unnamed) positional argument_i is assumed to be instantiated to values unequal to the instantiations of named arguments unicodestring_j -> filler_j.

(* iriconst? frameconj? *)
Typetag ( e1 . . . en )

<Typetag>
  <id> χχbld(iriconst)</id>?
  <meta> χχbld(frameconj)</meta>?
  e1' . . . en'
</Typetag>

where e1', . . ., en' are defined by the equation
 χχbld(Typetag(e1 . . . en)) = <Typetag>e1' . . . en'</Typetag>

(* iriconst? frameconj? *)
Quantifier variable1 . . . variablen (  bodypremise )

<Quantifier>
  <id> χχbld(iriconst)</id>?
  <meta> χχbld(frameconj)</meta>?
  <declare> χχbld(variable1)</declare>
  . . .
  <declare> χχbld(variablen)</declare>
  <formula> χχbld( bodypremise)</formula>
</Quantifier>

(* iriconst? frameconj? *)
pred (
  argument1
  . . .
  argumentn
     )

<Atom>
  <id> χχbld(iriconst)</id>?
  <meta> χχbld(frameconj)</meta>?
  <op> χχbld(pred)</op>
  <args  ordered="yes"> χordered="yes">
    χbld(argument1)
    . . .
     χχbld(argumentn)
  </args>
</Atom>

(* iriconst? frameconj? *)
func (
  argument1
  . . .
  argumentn
     )

<Expr>
  <id> χχbld(iriconst)</id>?
  <meta> χχbld(frameconj)</meta>?
  <op> χχbld(func)</op>
  <args  ordered="yes"> χordered="yes">
    χbld(argument1)
    . . .
     χχbld(argumentn)
  </args>
</Expr>

(* iriconst? frameconj? *)
pred (
  unicodestring1 -> filler1
  . . .
  unicodestringn -> fillern
     )

<Atom>
  <id> χχbld(iriconst)</id>?
  <meta> χχbld(frameconj)</meta>?
  <op> χχbld(pred)</op>
  <slot  ordered="yes">ordered="yes">
    <Name>unicodestring1</Name>
     χχbld(filler1)
  </slot>
   . . .
  <slot  ordered="yes">ordered="yes">
    <Name>unicodestringn</Name>
     χχbld(fillern)
  </slot>
</Atom>

(* iriconst? frameconj? *)
func (
  unicodestring1 -> filler1
  . . .
  unicodestringn -> fillern
     )

<Expr>
  <id> χχbld(iriconst)</id>?
  <meta> χχbld(frameconj)</meta>?
  <op> χχbld(func)</op>
  <slot  ordered="yes">ordered="yes">
    <Name>unicodestring1</Name>
     χχbld(filler1)
  </slot>
   . . .
  <slot  ordered="yes">ordered="yes">
    <Name>unicodestringn</Name>
     χχbld(fillern)
  </slot>
</Expr>

(* iriconst? frameconj? *)
inst [
  key1 -> filler1
  . . .
  keyn -> fillern
     ]

<Frame>
  <id> χχbld(iriconst)</id>?
  <meta> χχbld(frameconj)</meta>?
  <object> χχbld(inst)</object>
  <slot  ordered="yes"> χordered="yes">
    χbld(key1)
     χχbld(filler1)
  </slot>
   . . .
  <slot  ordered="yes"> χordered="yes">
    χbld(keyn)
     χχbld(fillern)
  </slot>
</Frame>

(* iriconst? frameconj? *)
e1 $ e2

<Binop>
  <id> χχbld(iriconst)</id>?
  <meta> χχbld(frameconj)</meta>?
  e1' e2'
</Binop>

where Binop, e1', e2' are defined by the equation
 χχbld(e1 $ e2) = <Binop>e1' e2'</Binop>

(* iriconst? frameconj? *)
unicodestring^^symspace

<Const  type="type="symspace ">">
  <id> χχbld(iriconst)</id>?
  <meta> χχbld(frameconj)</meta>?
  unicodestring
</Const>

(* iriconst? frameconj? *)
?unicodestring

<Var>
  <id> χχbld(iriconst)</id>?
  <meta> χχbld(frameconj)</meta>?
  unicodestring
</Var>

Let ΤΤ be a set of datatypes that includes the datatypes specified in [RIF-DTB], and suppose ΕΕ is a set of external predicates and functionsterms that includes the built-ins listed in [RIF-DTB]. We say that a formula φφ is a BLD _Τ,ΕΤ,Ε formula iff

• it is a well-formed BLD formula,
• all the datatypes used in φφ are in Τ,Τ, and
• all the externally defined functions and predicatesterms used in φφ are in Ε.Ε.

A RIF processor is a conformant BLD _Τ,ΕΤ,Ε consumer iff it implements a semantics-preserving mapping, μ,mapping, μ, from the set of all BLD _Τ,ΕΤ,Ε formulas to the language L of the processor.processor (μ does not need to be an "onto" mapping).

Formally, this means that for any pair φ, ψφ, ψ of BLD _Τ,ΕΤ,Ε formulas for which φφ |=_BLD ψψ is defined, φφ |=_BLD ψψ iff μ(φ)μ(φ) |=_L μ(ψ).μ(ψ). Here |=_BLD denotes the logical entailment in RIF-BLD and |=_L is the logical entailment in the language L of the RIF processor.

A RIF processor is a conformant BLD _Τ,ΕΤ,Ε producer iff it implements a semantics-preserving mapping, ν,mapping, ν, from a subset ofthe language L of the processor to athe set of all BLD _{Τ,Ε formulas.Τ,Ε} formulas (ν does not need to be an "onto" mapping).

Formally, this means that for any pair φ, ψφ, ψ of formulas in the aforesaid subset ofL for which φφ |=_L ψψ is defined, φφ |=_L ψψ iff ν(φ)ν(φ) |=_BLD ν(ψ).ν(ψ).

A conformant document is one which conforms to all the syntactic constraints of RIF-BLD, including ones that cannot be checked by an XML Schema validator (cf. Definition Conformant BLD document in XML syntax).

A round-tripping of a conformant BLD document is its semantics-preserving mapping to a document in any language L followed by a semantics-preserving mapping from the L document back to a conformant BLD document. While semantically equivalent, the original and the round-tripped BLD documents need not be identical. Metadata should survive BLD round-tripping.The above definitions are specializations to BLD of the general conformance clauses defined in the RIF framework for logic dialects [RIF-FLD]. The following clauses are further restrictions that are specific to RIF-BLD.

RIF-BLD specific clauses

• Conformant BLD producers and consumers are required to support only the entailments of the form φφ |=_BLD ψ,ψ, where ψψ is a closed RIF condition formula, i.e., an existentially quantifieda RIF condition in which every variable, ?V, is in the scope of a quantifier of the form Exists ?VExists ?V. In addition, conformant BLD producers and consumers SHOULD preserve all annotations where possible.

• A conformant RIF-BLD consumer is a conformant BLD _Τ,ΕΤ,Ε consumer in which ΤΤ consists only of the datatypes and ΕΕ consists only of the externally defined functionsterms (functions and predicatespredicates) that are required by RIF-BLD. These datatypes and externally defined terms (called built-ins) are specified in [RIF-DTB]. A conformant RIF-BLD consumer must reject all inputs that do not match the syntax of BLD. If it implements extensions, it may do so under user control -- having a "strict BLD""strict BLD" mode and a "run-with-extensions""run-with-extensions" mode.

• A conformant BLD producer is a conformant BLD _Τ,ΕΤ,Ε producer, which produces documents that include only the datatypes and externals that are required by BLD.

RIF-BLD supports a wide variety of syntactic forms for terms and formulas, which creates infrastructure for exchanging syntactically diverse rule languages. It is important to realize, however, that the above conformance statements make it possible for the systems that do not support some of the syntax directly to still support it through syntactic transformations. For instance, disjunctions in the rule premises can be eliminated through a standard transformation, such as replacing p :-p :- Or(q r) with a pair of rules p :-p :- q,   p :-  p :- r. Terms with named arguments can be reduced to positional terms by ordering the arguments by their names and incorporating the ordered argument names into the predicate name. For instance, p(bb->1 aa->2) can be represented as p_aa_bb(2,1).

6 RIF-BLD as a Specialization of the RIF Framework [RIF-FLD]

This normative section describes RIF-BLD by specializing RIF-FLD. The reader is assumed to be familiar with RIF-FLD as described in RIF framework for logic dialects [RIF-FLD]. The reader who is not interested in how RIF-BLD is derived from the framework can skip this section.

The presentation syntax of the RIF Basic Logic Dialect is defined by specialization from the presentation syntax of the RIF Syntactic Framework for Logic Dialects described in [RIF-FLD]. Section Syntax of a RIF Dialect as a Specialization of the RIF Framework in [RIF-FLD] lists the parameters of the syntactic framework in mathematical English, which we will now specialize for RIF-BLD.

1. Alphabet.

   The alphabet of the RIF-BLD presentation syntax is the alphabet of RIF-FLD with the symbols Dialect, Neg, and Naf excluded.

2. Assignment of signatures to each constant and variable symbol.

   The signature set of RIF-BLD contains the following signatures:

   1. Basic
      • individual{ } atomic{ }individual{ }
      • atomic{ }

      The signature individual{ }individual{ } represents the context in which individual objects (but not atomic formulas) can appear.
      The signature atomic{ }atomic{ } represents the context where atomic formulas can occur.

   2. For every integer n ≥≥ 0, there are signatures
      • f_n{(individual ... individual) ⇒⇒ individual} -- for n-ary function symbols,
      • p_n{(individual ... individual) ⇒⇒ atomic} -- for n-ary predicates.
      • ef_n{(individual ... individual) ⇒⇒ individual} -- for n-ary external function symbols,
      • ep_n{(individual ... individual) ⇒⇒ atomic} -- for n-ary external predicates.

      These represent function and predicate symbols of arity n (each of the above cases has n individuals as arguments inside the parentheses).

   3. For every set of symbols s1,...,sk ∈∈ ArgNames, there are signatures
      • f_s1...sk{(s1->individual ... sk->individual) ⇒⇒ individual}
      • p_s1...sk{(s1->individual ... sk->individual) ⇒⇒ atomic}.
      • ef_s1...sk{(s1->individual ... sk->individual) ⇒⇒ individual}
      • ep_s1...sk{(s1->individual ... sk->individual) ⇒⇒ atomic}.

      These are signatures for terms and predicates with arguments named s1, ..., sk, respectively. The signatures ef_s1...sk and ep_s1...sk are for external symbols. In this specialization of RIF-FLD, the argument names s1, ..., sk must be pairwise distinct.

   4. A symbol in Const can have exactly one signature, individual, f_n, p_n, ef_n, ep_n, where n ≥≥ 0, or f_s1...sk, p_s1...sk, ef_s1...sk, or ep_s1...sk, for some s1,...,sk ∈∈ ArgNames. It cannot have the signature atomic, since only complex terms can have such signatures. Thus, by itself a symbol cannot be a proposition in RIF-BLD, but a term of the form p() can be.

      Accordingly, in RIF-BLD each constant symbol can be either an individual, a function of one particular arity, a predicate of one particular arity, an externally defined function symbol of one particular arity, or an externally defined predicate symbol of one particular arity -- it is not possible for the same symbol to play more than one role.

   5. The constant symbols that belong to the primitive RIF datatypes (XML Schema datatypes, rdf:XMLLiteral, rif:textrdf:text, etc.) all have the signature individual in RIF-BLD.
   6. The symbols of type rif:iri and rif:local can have the following signatures in RIF-BLD: individual, f_n, p_n, ef_n, or ep_n, for n = 0,1,....; or f_s1...sk, p_s1...sk, ef_s1...sk, or ep_s1...sk, for some argument names s1,...,sk ∈∈ ArgNames.
   7. All variables are associated with signature individual{ }individual{ }, so they can range only over individuals.
   8. The signature for equality is ={(individual individual) ⇒={(individual individual) ⇒ atomic}.

      This means that equality can compare only those terms whose signature is individual; it cannot compare predicate or function symbols. Equality terms are also not allowed to occur inside other terms, since the above signature implies that any term of the form t = s has signature atomic and not individual.

   9. The frame signature, ->, is ->{(individual individual individual) ⇒->{(individual individual individual) ⇒ atomic}.

      Note that this precludes the possibility that a frame term might occur as an argument to a predicate, a function, or inside some other term.

   10. The membership signature, #, is #{(individual individual) ⇒#{(individual individual) ⇒ atomic}.

       Note that this precludes the possibility that a membership term might occur as an argument to a predicate, a function, or inside some other term.

   11. The signature for the subclass relationship is ##{(individual individual) ⇒##{(individual individual) ⇒ atomic}.

       As with frames and membership terms, this precludes the possibility that a subclass term might occur inside some other term.

   RIF-BLD uses no special syntax for declaring signatures. Instead, the rule author specifies signatures contextually. That is, since RIF-BLD requires that each symbol is associated with a unique signature, the signature is determined from the context in which the symbol is used. If a symbol is used in more than one context, the parser must treat this as a syntax error. If no errors are found, all terms and atomic formulas are guaranteed to be well-formed. Thus, signatures are not part of the RIF-BLD language, and individual and atomic are not reserved keywords.

3. Supported types of terms.
   • RIF-BLD supports the following types of terms defined by the syntactic framework (see the Section Terms of [RIF-FLD]):
     1. constants
     2. variables
     3. positional
     4. with named arguments
     5. equality
     6. frame
     7. membership
     8. subclass
     9. external
   • Compared to RIF-FLD, terms (both positional and with named arguments) have significant restrictions in order to keep BLD relatively simple.
     • The signature for the variable symbols does not permit them to occur in the context of predicates, functions, or formulas. In particular, in the RIF-BLD specialization of RIF-FLD, a variable is not an atomic formula.
     • Likewise, a symbol cannot be an atomic formula by itself. That is, if p ∈∈ Const then p is not a well-formed atomic formula. However, p() can be an atomic formula.
     • Signatures permit only constant symbols to occur in the context of function or predicate names. Indeed, RIF-BLD signatures ensure that all variables have the signature individual{ }individual{ } and all other terms, except for the constants from Const, can have either the signature individual{ }individual{ } or atomic{ }atomic{ }. Therefore, if t is a (non-Const) term then t(...) is not a well-formed term.
     • In an externally defined term, External(t), t can be only a positional, named-argument, or a frame term. Compared to RIF-FLD, this restricts t so that it cannot be a constant.

       Combined with the fact that in a well-formed term of the form External(t) the subterm t must be an instance of an external schema (by the definition of well-formed external terms in RIF-FLD), it follows that a predicate or a function symbol, p, that occurs in an external term External(p(...)) cannot also occur as a non-external symbol.

     • If a term, t, is an instance of an externally defined schema from the coherent set of external schemas associated with the language, then t can occur only as External(t), i.e., as an external term or atomic formula.
4. Required symbol spaces.

   RIF-BLD requires the symbol spaces defined in Section Constants and Symbol Spaces of [RIF-DTB].

5. Supported formulas.

   RIF-BLD supports the following types of formulas (see Well-formed Terms and Formulas in [RIF-FLD] for the definitions):

   • RIF-BLD condition

     A RIF-BLD condition is an atomic formula, a conjunctive or disjunctive combination of atomic formulas, or an external atomic formula. All these can optionally have existential quantifiers.

   • RIF-BLD rule

     A RIF-BLD rule is a universally quantified RIF-FLD rule with the following restrictions:

     • The head (or conclusion)The conclusion of the rule is an atomic formula or a conjunction of atomic formulas.

       Note: This feature (Equality in the rule conclusion) is "at risk""at risk". See feature at risk #2

     • None of the atomic formulas mentioned in the rule headconclusion is externally defined (i.e., cannot have the form External(...)).
     • The body (or premise)premise of the rule is a RIF-BLD condition.
     • All free (non-quantified) variables in the rule must be quantified with Forall outside of the rule (i.e., Forall ?vars (head :- body)Forall ?vars (conclusion :- premise)).
   • Universal fact

     A universal fact is a universally quantified atomic formula with no free variables.

   • RIF-BLD group

     A RIF-BLD group is a RIF-FLD group that contains only RIF-BLD rules, universal facts, variable-free rule implications, variable-free atomic formulas, and RIF-BLD groups.

   • RIF-BLD document

     A RIF-BLD document is a RIF-FLD document that consists of directives and a RIF-BLD group formula. There is no Dialect directive and the Import(loc) directive (with one argument) can import RIF-BLD documents only. There are no BLD-specific restrictions on the two-argument directive Import.

Recall that negation (classical or default) is not supported by RIF-BLD in either the rule headconclusion or the body.premise.

This normative section defines the precise relationship between the semantics of RIF-BLD and the semantic framework of RIF-FLD. Specification of the semantics that does not rely on RIF-FLD is given in Section Direct Specification of RIF-BLD Semantics.

The semantics of the RIF Basic Logic Dialect is defined by specialization from the semantics of the semantic framework for logic dialects of RIF. Section Semantics of a RIF Dialect as a Specialization of the RIF Framework in [RIF-FLD] lists the parameters of the semantic framework that can be specialized. Thus, for RIF-BLD, we need to look at the following parameters:

• The effect of the syntax.

  RIF-BLD does not support negation. This is the only obvious simplification with respect to RIF-FLD as far as the semantics is concerned. The restrictions on the signatures of symbols in RIF-BLD do not affect the semantics in a significant way.

• Truth values.

  The set TV of truth values in RIF-BLD consists of just two values, t and f such that f <_t t. The order <_t is total.

• Datatypes.

  RIF-BLD supports the datatypes listed in Section Datatypes of [RIF-DTB].

• Logical entailment.

  Recall that logical entailment in RIF-FLD is defined with respect to an unspecified set of intended semantic structures and that dialects of RIF must make this notion concrete. For RIF-BLD, this set is defined in one ofthe two following equivalent ways: as aset of all models; or as the unique minimal model, if it exists. (Note that such a model might not exist because of equality and built-in predicates associated with the RIF-BLD required datatypes ). These two definitions are equivalent for entailment of existentially closed RIF-BLD conditions by RIF-BLD documents (i.e., formulas where every variable, ?V , occurs in a subformula of the form Exists ...?V...(ψ) ), since all rules in RIF-BLD are Horn -- it is a classical result of Van Emden and Kowalski [ vEK76 ].models.

• Import directive.

  The semantics of the two-argument Import directive is given in [RIF-RDF+OWL]. The semantics of the one-argument directive is the same as in RIF-FLD.

Section Mapping from the RIF-FLD Presentation Syntax to the XML Syntax of [RIF-FLD] defines a mapping, χχ_fld, from the presentation syntax of RIF-FLD to its XML serialization. When restricted to well-formed RIF-BLD formulas, χχ_fld coincides with the BLD-to-XML mapping χχ_bld. In this way, the XML serialization of RIF-BLD is a specialization of the RIF-FLD XML Serialization Framework defined in [RIF-FLD].

If T is a set of datatypes and E a set of externally defined functions and predicates, then the general definition of conformance in RIF-FLD yields the notion of conformant BLD_T,E producers and consumers.

BLD further requires strictness, i.e., that a conformant producer produces only the documents where T and E are precisely the datatypes and externals specified in [RIF-DTB], and that a conformant consumer consumes only such documents.

[RDF-CONCEPTS]

Resource Description Framework (RDF): Concepts and Abstract Syntax, Klyne G., Carroll J. (Editors), W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-concepts-20040210/. Latest version available at http://www.w3.org/TR/rdf-concepts/.

[RFC-3066]

RFC 3066 - Tags for the Identification of Languages, H. Alvestrand, IETF, January 2001. This document is http://www.isi.edu/in-notes/rfc3066.txt.

[RFC-3987]

RFC 3987 - Internationalized Resource Identifiers (IRIs), M. Duerst and M. Suignard, IETF, January 2005. This document is http://www.ietf.org/rfc/rfc3987.txt.

[RIF-DTB]

RIF Datatypes and Built-Ins 1.0 Axel Polleres, Harold Boley, Michael Kifer, eds. W3C Editor'sWorking Draft, 22 September18 December 2008, http://www.w3.org/2005/rules/wg/draft/ED-rif-dtb-20080922/http://www.w3.org/TR/2008/WD-rif-dtb-20081218/. Latest version available at http://www.w3.org/2005/rules/wg/draft/rif-dtb/http://www.w3.org/TR/rif-dtb/.

[RIF-FLD]

RIF Framework for Logic Dialects Harold Boley, Michael Kifer, eds. W3C Editor'sWorking Draft, 22 September30 July 2008, http://www.w3.org/2005/rules/wg/draft/ED-rif-fld-20080922/http://www.w3.org/TR/2008/WD-rif-fld-20080730/. Latest version available at http://www.w3.org/2005/rules/wg/draft/rif-fld/http://www.w3.org/TR/rif-fld/.

[RIF-PRD]

RIF Production Rule Dialect Christian de Sainte Marie, Adrian Paschke, Gary Hallmark, eds. W3C Working Draft, 18 December 2008, http://www.w3.org/TR/2008/WD-rif-prd-20081218/. Latest version available at http://www.w3.org/TR/rif-prd/.

[RIF-RDF+OWL]

RIF RDF and OWL Compatibility Jos de Bruijn, eds.editor. W3C Editor'sWorking Draft, 22 September30 July 2008, http://www.w3.org/2005/rules/wg/draft/ED-rif-rdf-owl-20080922/http://www.w3.org/TR/2008/WD-rif-rdf-owl-20080730/. Latest version available at http://www.w3.org/2005/rules/wg/draft/rif-rdf-owl/http://www.w3.org/TR/rif-rdf-owl/.

[XML1.0]

Extensible Markup Language (XML) 1.0 (Fourth Edition), W3C Recommendation, World Wide Web Consortium, 16 August 2006, edited in place 29 September 2006. This version is http://www.w3.org/TR/2006/REC-xml-20060816/.

[XML-Base]

XML Base, W3C Recommendation, World Wide Web Consortium, 27 June 2001. This version is http://www.w3.org/TR/2001/REC-xmlbase-20010627/. The latest version is available at http://www.w3.org/TR/xmlbase/.

[XML-SCHEMA2]

XML Schema Part 2: Datatypes, W3C Recommendation, World Wide Web Consortium, 2 May 2001. This version is http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/. The latest version is available at http://www.w3.org/TR/xmlschema-2/.

[ANF01]

Normal Form Conventions for XML Representations of Structured Data, Henry S. Thompson. October 2001. Available at http://www.ltg.ed.ac.uk/~ht/normalForms.html.

[AG08]

The Expressive Power of SPARQL, Renzo Angles and Claudio Gutierrez. International Semantic Web Conference 2008: 114-129

[AP07]

From SPARQL to rules (and back), Axel Polleres. WWW 2007: 787-796

[CG]

Information Processing, John Sowa, in Mind and Machine. JReading, MA: Addison-Wesley Publ., 1984.

[CL73]

Symbolic Logic and Mechanical Theorem Proving, C.L. Chang and R.C.T. Lee. Academic Press, 1973.

[CL07]

ISO/IEC 24707:2007. The ISO Common Logic Standard. Available through http://common-logic.org

[CURIE]

CURIE Syntax 1.0: A syntax for expressing Compact URIs, Mark Birbeck, Shane McCarron. W3C Working Draft 2 April 2008. Available at http://www.w3.org/TR/curie/.

[Enderton01]

A Mathematical Introduction to Logic, Second Edition, H. B. Enderton. Academic Press, 2001.

[KIF]

Knowledge Interchange Format, M. Genesereth, et al. 1998. Available at http://logic.stanford.edu/kif/dpans.html

[KLW95]

Logical foundations of object-oriented and frame-based languages, M. Kifer, G. Lausen, J. Wu. Journal of ACM, July 1995, pp. 741--843.

[Mendelson97]

Introduction to Mathematical Logic, Fourth Edition, E. Mendelson. Chapman & Hall, 1997.

[OWL-Reference]

OWL Web Ontology Language Reference, M. Dean, G. Schreiber, Editors, W3C Recommendation, 10 February 2004. Latest version available at http://www.w3.org/TR/owl-ref/.

[RDFSYN04]

RDF/XML Syntax Specification (Revised), Dave Beckett, Editor, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-syntax-grammar-20040210/. Latest version available at http://www.w3.org/TR/rdf-syntax-grammar/.

[RIF-UCR]

RIF Use Cases and Requirements Adrian Paschke, David Hirtle, Allen Ginsberg, Paula-Lavinia Patranjan, Frank McCabe, eds. W3C Editor'sWorking Draft, 22 September18 December 2008, http://www.w3.org/2005/rules/wg/draft/ED-rif-ucr-20080922/http://www.w3.org/TR/2008/WD-rif-ucr-20081218/. Latest version available at http://www.w3.org/2005/rules/wg/draft/rif-ucr/http://www.w3.org/TR/rif-ucr/.

[TRT03]

Object-Oriented RuleML: User-Level Roles, URI-Grounded Clauses, and Order-Sorted Terms, H. Boley. Springer LNCS 2876, Oct. 2003, pp. 1-16. Preprint at http://iit-iti.nrc-cnrc.gc.ca/publications/nrc-46502_e.html.

[vEK76]

The semantics of predicate logic as a programming language, M. van Emden and R. Kowalski. Journal of the ACM 23 (1976), pp. 733-742.

XML schemas for the RIF-BLD sublanguages are defined below and are also available here with additional examples.

 <?xml  version="1.0" encoding="UTF-8"?>version="1.0" encoding="UTF-8"?>
 
 <xs:schema 
   xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="http://www.w3.org/2007/rif#" targetNamespace="http://www.w3.org/2007/rif#" elementFormDefault="qualified" version="Id:xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns="http://www.w3.org/2007/rif#"
  targetNamespace="http://www.w3.org/2007/rif#"
  elementFormDefault="qualified"
  version="Id: BLDCond.xsd, v. 1.0, 2008-07-20,  dhirtle/hboley">dhirtle/hboley">
 
  <xs:annotation>
    <xs:documentation>
    This is the XML schema for the Condition Language as defined by
    the Last Call Draft of the RIF Basic Logic Dialect.
    
    The schema is based on the following EBNF for the RIF-BLD Condition Language:
 
  FORMULA        ::= IRIMETA? 'And' '(' FORMULA* ')' |
                     IRIMETA? 'Or' '(' FORMULA* ')' |
                     IRIMETA? 'Exists' Var+ '(' FORMULA ')' |
                     ATOMIC |
                     IRIMETA? 'External' '(' Atom | Frame ')'
  ATOMIC         ::= IRIMETA? (Atom | Equal | Member | Subclass | Frame)
  Atom           ::= UNITERM
  UNITERM        ::= Const '(' (TERM* | (Name '->' TERM)*) ')'
  Equal          ::= TERM '=' TERM
  Member         ::= TERM '#' TERM
  Subclass       ::= TERM '##' TERM
  Frame          ::= TERM '[' (TERM '->' TERM)* ']'
  TERM           ::= IRIMETA? (Const | Var | Expr | 'External' '(' Expr ')')
  Expr           ::= UNITERM
  Const          ::=  '"''"' UNICODESTRING  '"^^''"^^' SYMSPACE | CONSTSHORT
  Name           ::= UNICODESTRING
  Var            ::= '?' UNICODESTRING
  SYMSPACE       ::= ANGLEBRACKIRI | CURIE
 
  IRIMETA        ::= '(*' IRICONST? (Frame | 'And' '(' Frame* ')')? '*)'
 
    </xs:documentation>
  </xs:annotation>
  
  <xs:group  name="FORMULA">name="FORMULA">  
    <!--
  FORMULA        ::= IRIMETA? 'And' '(' FORMULA* ')' |
                     IRIMETA? 'Or' '(' FORMULA* ')' |
                     IRIMETA? 'Exists' Var+ '(' FORMULA ')' |
                     ATOMIC |
                     IRIMETA? 'External' '(' Atom | Frame ')'
    -->
    <xs:choice>
      <xs:element  ref="And"/>ref="And"/>
      <xs:element  ref="Or"/>ref="Or"/>
      <xs:element  ref="Exists"/>ref="Exists"/>
      <xs:group  ref="ATOMIC"/>ref="ATOMIC"/>
      <xs:element  name="External" type="External-FORMULA.type"/>name="External" type="External-FORMULA.type"/>
    </xs:choice>
  </xs:group>
  
  <xs:complexType  name="External-FORMULA.type">name="External-FORMULA.type">
    <!-- sensitive to FORMULA (Atom | Frame) context-->
    <xs:sequence>
      <xs:group  ref="IRIMETA" minOccurs="0" maxOccurs="1"/>ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
      <xs:element  name="content" type="content-FORMULA.type"/>name="content" type="content-FORMULA.type"/>
    </xs:sequence>
  </xs:complexType>
  
  <xs:complexType  name="content-FORMULA.type">name="content-FORMULA.type">
    <!-- sensitive to FORMULA (Atom | Frame) context-->
    <xs:sequence>
      <xs:choice>
        <xs:element  ref="Atom"/>ref="Atom"/>
        <xs:element  ref="Frame"/>ref="Frame"/>
      </xs:choice>
    </xs:sequence>
  </xs:complexType>
 
  <xs:element  name="And">name="And">
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="IRIMETA" minOccurs="0" maxOccurs="1"/> <xs:element ref="formula" minOccurs="0" maxOccurs="unbounded"/>ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
        <xs:element ref="formula" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
  <xs:element  name="Or">name="Or">
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="IRIMETA" minOccurs="0" maxOccurs="1"/> <xs:element ref="formula" minOccurs="0" maxOccurs="unbounded"/>ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
        <xs:element ref="formula" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
  <xs:element  name="Exists">name="Exists">
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="IRIMETA" minOccurs="0" maxOccurs="1"/> <xs:element ref="declare" minOccurs="1" maxOccurs="unbounded"/>ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
        <xs:element ref="declare" minOccurs="1" maxOccurs="unbounded"/>
        <xs:element  ref="formula"/>ref="formula"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
  <xs:element  name="formula">name="formula">
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="FORMULA"/>ref="FORMULA"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
  <xs:element  name="declare">name="declare">
    <xs:complexType>
      <xs:sequence>
        <xs:element  ref="Var"/>ref="Var"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
 
  <xs:group  name="ATOMIC">name="ATOMIC">
    <!--
  ATOMIC         ::= IRIMETA? (Atom | Equal | Member | Subclass | Frame)
    -->
    <xs:choice>
      <xs:element  ref="Atom"/>ref="Atom"/>
      <xs:element  ref="Equal"/>ref="Equal"/>
      <xs:element  ref="Member"/>ref="Member"/>
      <xs:element  ref="Subclass"/>ref="Subclass"/>
      <xs:element  ref="Frame"/>ref="Frame"/>
    </xs:choice>
  </xs:group>
  
  <xs:element  name="Atom">name="Atom">
    <!--
  Atom           ::= UNITERM
    -->
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="UNITERM"/>ref="UNITERM"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>  
  
  <xs:group  name="UNITERM">name="UNITERM">
    <!--
  UNITERM        ::= Const '(' (TERM* | (Name '->' TERM)*) ')'
    -->
    <xs:sequence>
      <xs:group  ref="IRIMETA" minOccurs="0" maxOccurs="1"/>ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
      <xs:element  ref="op"/>ref="op"/>
      <xs:choice>
        <xs:element  ref="args" minOccurs="0" maxOccurs="1"/> <xs:element name="slot" type="slot-UNITERM.type" minOccurs="0" maxOccurs="unbounded"/>ref="args" minOccurs="0" maxOccurs="1"/>
        <xs:element name="slot" type="slot-UNITERM.type" minOccurs="0" maxOccurs="unbounded"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
 
  <xs:element  name="op">name="op">
    <xs:complexType>
      <xs:sequence>
        <xs:element  ref="Const"/>ref="Const"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
  <xs:element  name="args">name="args">
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="TERM" minOccurs="0" maxOccurs="unbounded"/>ref="TERM" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute  name="ordered" type="xs:string" fixed="yes"/>name="ordered" type="xs:string" fixed="yes"/>
    </xs:complexType>
  </xs:element>
 
  <xs:complexType  name="slot-UNITERM.type">name="slot-UNITERM.type">
    <!-- sensitive to UNITERM (Name) context-->
    <xs:sequence>
      <xs:element  ref="Name"/>ref="Name"/>
      <xs:group  ref="TERM"/>ref="TERM"/>
    </xs:sequence>
    <xs:attribute  name="ordered" type="xs:string" fixed="yes"/>name="ordered" type="xs:string" fixed="yes"/>
  </xs:complexType>
 
  <xs:element  name="Equal">name="Equal">
    <!--
  Equal          ::= TERM '=' TERM
    -->
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="IRIMETA" minOccurs="0" maxOccurs="1"/>ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
        <xs:element  ref="left"/>ref="left"/>
        <xs:element  ref="right"/>ref="right"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
 
  <xs:element  name="left">name="left">
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="TERM"/>ref="TERM"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
 
  <xs:element  name="right">name="right">
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="TERM"/>ref="TERM"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
 
  <xs:element  name="Member">name="Member">
    <!--
  Member         ::= TERM '#' TERM
    -->
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="IRIMETA" minOccurs="0" maxOccurs="1"/>ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
        <xs:element  ref="instance"/>ref="instance"/>
        <xs:element  ref="class"/>ref="class"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
 
  <xs:element  name="Subclass">name="Subclass">
    <!--
  Subclass       ::= TERM '##' TERM
    -->
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="IRIMETA" minOccurs="0" maxOccurs="1"/>ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
        <xs:element  ref="sub"/>ref="sub"/>
        <xs:element  ref="super"/>ref="super"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
  <xs:element  name="instance">name="instance">
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="TERM"/>ref="TERM"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
  <xs:element  name="class">name="class">
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="TERM"/>ref="TERM"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
  <xs:element  name="sub">name="sub">
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="TERM"/>ref="TERM"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
  <xs:element  name="super">name="super">
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="TERM"/>ref="TERM"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
    
  <xs:element  name="Frame">name="Frame">
    <!--
  Frame          ::= TERM '[' (TERM '->' TERM)* ']'
    -->
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="IRIMETA" minOccurs="0" maxOccurs="1"/> <xs:element ref="object"/> <xs:element name="slot" type="slot-Frame.type" minOccurs="0" maxOccurs="unbounded"/>ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
        <xs:element ref="object"/>
        <xs:element name="slot" type="slot-Frame.type" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
 
  <xs:element  name="object">name="object">
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="TERM"/>ref="TERM"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
 
  <xs:complexType  name="slot-Frame.type">name="slot-Frame.type">
    <!-- sensitive to Frame (TERM) context-->
    <xs:sequence>
      <xs:group  ref="TERM"/>ref="TERM"/>
      <xs:group  ref="TERM"/>ref="TERM"/>
    </xs:sequence>
    <xs:attribute  name="ordered" type="xs:string" fixed="yes"/>name="ordered" type="xs:string" fixed="yes"/>
  </xs:complexType>
 
  <xs:group  name="TERM">name="TERM">  
    <!--
  TERM           ::= IRIMETA? (Const | Var | Expr | 'External' '(' Expr ')')
    -->
      <xs:choice>
         <xs:element  ref="Const"/>ref="Const"/>
         <xs:element  ref="Var"/>ref="Var"/>
         <xs:element  ref="Expr"/>ref="Expr"/>
         <xs:element  name="External" type="External-TERM.type"/>name="External" type="External-TERM.type"/>
      </xs:choice>
  </xs:group>
  
  <xs:complexType  name="External-TERM.type">name="External-TERM.type">
    <!-- sensitive to TERM (Expr) context-->
    <xs:sequence>
      <xs:group  ref="IRIMETA" minOccurs="0" maxOccurs="1"/>ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
      <xs:element  name="content" type="content-TERM.type"/>name="content" type="content-TERM.type"/>
    </xs:sequence>
  </xs:complexType>
  
  <xs:complexType  name="content-TERM.type">name="content-TERM.type">
    <!-- sensitive to TERM (Expr) context-->
    <xs:sequence>
      <xs:element  ref="Expr"/>ref="Expr"/>
    </xs:sequence>
  </xs:complexType>
 
  <xs:element  name="Expr">name="Expr">
    <!--
  Expr           ::= UNITERM
    -->
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="UNITERM"/>ref="UNITERM"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
 
  <xs:element  name="Const">name="Const">
    <!--
  Const          ::=  '"''"' UNICODESTRING  '"^^''"^^' SYMSPACE | CONSTSHORT
    -->
    <xs:complexType  mixed="true">mixed="true">
      <xs:sequence>
        <xs:group  ref="IRIMETA" minOccurs="0" maxOccurs="1"/>ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
      </xs:sequence>
      <xs:attribute  name="type" type="xs:anyURI" use="required"/>name="type" type="xs:anyURI" use="required"/>
    </xs:complexType>
  </xs:element>
  
  <xs:element  name="Name" type="xs:string">name="Name" type="xs:string">
    <!--
  Name           ::= UNICODESTRING
    -->
  </xs:element>
 
  <xs:element  name="Var">name="Var">
    <!--
  Var            ::= '?' UNICODESTRING
    -->
    <xs:complexType  mixed="true">mixed="true">
      <xs:sequence>
        <xs:group  ref="IRIMETA" minOccurs="0" maxOccurs="1"/>ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
 
  <xs:group  name="IRIMETA">name="IRIMETA">
    <!--
  IRIMETA   ::= '(*' IRICONST? (Frame | 'And' '(' Frame* ')')? '*)'
    -->
    <xs:sequence>
      <xs:element  ref="id" minOccurs="0" maxOccurs="1"/> <xs:element ref="meta" minOccurs="0" maxOccurs="1"/>ref="id" minOccurs="0" maxOccurs="1"/>
      <xs:element ref="meta" minOccurs="0" maxOccurs="1"/>
    </xs:sequence>
  </xs:group>
 
  <xs:element  name="id">name="id">
    <xs:complexType>
      <xs:sequence>
        <xs:element  name="Const" type="IRICONST.type"/>name="Const" type="IRICONST.type"/>   <!--  type="&rif;iri"type="&rif;iri" -->
      </xs:sequence>
    </xs:complexType>
  </xs:element>
 
  <xs:element  name="meta">name="meta">
    <xs:complexType>
     <xs:choice>
       <xs:element  ref="Frame"/>ref="Frame"/>
       <xs:element  name="And" type="And-meta.type"/>name="And" type="And-meta.type"/>
     </xs:choice>
    </xs:complexType>
  </xs:element>
  
  <xs:complexType  name="And-meta.type">name="And-meta.type">
  <!-- sensitive to meta (Frame) context-->
    <xs:sequence>
      <xs:element  name="formula" type="formula-meta.type" minOccurs="0" maxOccurs="unbounded"/>name="formula" type="formula-meta.type" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>
 
  <xs:complexType  name="formula-meta.type">name="formula-meta.type">
    <!-- sensitive to meta (Frame) context-->
    <xs:sequence>
      <xs:element  ref="Frame"/>ref="Frame"/>
    </xs:sequence>
  </xs:complexType>
  
  <xs:complexType  name="IRICONST.type" mixed="true">name="IRICONST.type" mixed="true">
    <!-- sensitive to location/id context-->
    <xs:sequence/>
    <xs:attribute  name="type" type="xs:anyURI" use="required" fixed="http://www.w3.org/2007/rif#iri"/>name="type" type="xs:anyURI" use="required" fixed="http://www.w3.org/2007/rif#iri"/>
  </xs:complexType>
  
 </xs:schema>

 <?xml  version="1.0" encoding="UTF-8"?>version="1.0" encoding="UTF-8"?>
 
 <xs:schema 
   xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="http://www.w3.org/2007/rif#" targetNamespace="http://www.w3.org/2007/rif#" elementFormDefault="qualified" version="Id:xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns="http://www.w3.org/2007/rif#"
  targetNamespace="http://www.w3.org/2007/rif#"
  elementFormDefault="qualified"
  version="Id: BLDRule.xsd, v. 1.0, 2008-07-16,  dhirtle/hboley">dhirtle/hboley">
 
  <xs:annotation>
    <xs:documentation>
    This is the XML schema for the Rule Language as defined by
    the Last Call Draft of the RIF Basic Logic Dialect.
    
    The schema is based on the following EBNF for the RIF-BLD Rule Language:
  
  Document  ::= IRIMETA? 'Document' '(' Base? Prefix* Import* Group? ')'
  Base      ::= 'Base' '(' IRI ')'
  Prefix    ::= 'Prefix' '(' Name IRI ')'
  Import    ::= IRIMETA? 'Import' '(' IRICONST PROFILE? ')'
  Group     ::= IRIMETA? 'Group' '(' (RULE | Group)* ')'
  RULE      ::= (IRIMETA? 'Forall' Var+ '(' CLAUSE ')') | CLAUSE
  CLAUSE    ::= Implies | ATOMIC
  Implies   ::= IRIMETA? (ATOMIC | 'And' '(' ATOMIC* ')') ':-' FORMULA
  PROFILE   ::= TERM
      
    Note that this is an extension of the syntax for the RIF-BLD Condition Language (BLDCond.xsd).
    </xs:documentation>
  </xs:annotation>
 
  <!-- The Rule Language includes the Condition Language from the same directory -->
  <xs:include  schemaLocation="BLDCond.xsd"/>schemaLocation="BLDCond.xsd"/>
 
  <xs:element  name="Document">name="Document">
    <!--
  Document  ::= IRIMETA? 'Document' '(' Base? Prefix* Import* Group? ')'
    -->
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="IRIMETA" minOccurs="0" maxOccurs="1"/> <xs:element ref="directive" minOccurs="0" maxOccurs="unbounded"/> <xs:element ref="payload" minOccurs="0" maxOccurs="1"/>ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
        <xs:element ref="directive" minOccurs="0" maxOccurs="unbounded"/>
        <xs:element ref="payload" minOccurs="0" maxOccurs="1"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
 
  <xs:element  name="directive">name="directive">
    <!--
  Base and Prefix represented directly in XML
    -->
    <xs:complexType>
      <xs:sequence>
        <xs:element  ref="Import"/>ref="Import"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
 
  <xs:element  name="payload">name="payload">
    <xs:complexType>
      <xs:sequence>
        <xs:element  ref="Group"/>ref="Group"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
  <xs:element  name="Import">name="Import">
    <!--
  Import    ::= IRIMETA? 'Import' '(' IRICONST PROFILE? ')'
    -->
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="IRIMETA" minOccurs="0" maxOccurs="1"/> <xs:element ref="location"/> <xs:element ref="profile" minOccurs="0" maxOccurs="1"/>ref="IRIMETA" minOccurs="0" maxOccurs="1"/> 
        <xs:element ref="location"/>
        <xs:element ref="profile" minOccurs="0" maxOccurs="1"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
 
  <xs:element  name="location">name="location">
    <xs:complexType>
      <xs:sequence>
        <xs:element  name="Const" type="IRICONST.type"/>name="Const" type="IRICONST.type"/>   <!--  type="&rif;iri"type="&rif;iri" -->
      </xs:sequence>
    </xs:complexType>
  </xs:element>
 
  <xs:element  name="profile">name="profile">
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="TERM"/>ref="TERM"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
  <xs:element  name="Group">name="Group">
    <!--
  Group     ::= IRIMETA? 'Group' '(' (RULE | Group)* ')'
    -->
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="IRIMETA" minOccurs="0" maxOccurs="1"/> <xs:element ref="sentence" minOccurs="0" maxOccurs="unbounded"/>ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
        <xs:element ref="sentence" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
 
  <xs:element  name="sentence">name="sentence">
   <xs:complexType>
     <xs:choice>
       <xs:group  ref="RULE"/>ref="RULE"/>
       <xs:element  ref="Group"/>ref="Group"/>
     </xs:choice>
   </xs:complexType>
 </xs:element>
  
  <xs:group  name="RULE">name="RULE">
    <!--
  RULE      ::= (IRIMETA? 'Forall' Var+ '(' CLAUSE ')') | CLAUSE
    -->
    <xs:choice>
      <xs:element  ref="Forall"/>ref="Forall"/>
      <xs:group  ref="CLAUSE"/>ref="CLAUSE"/>
    </xs:choice>
  </xs:group>
 
  <xs:element  name="Forall">name="Forall">
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="IRIMETA" minOccurs="0" maxOccurs="1"/> <xs:element ref="declare" minOccurs="1" maxOccurs="unbounded"/>ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
        <xs:element ref="declare" minOccurs="1" maxOccurs="unbounded"/>
        <!-- different from formula in And, Or and Exists -->
        <xs:element  name="formula">name="formula">
          <xs:complexType>
            <xs:group  ref="CLAUSE"/>ref="CLAUSE"/>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
 
  <xs:group  name="CLAUSE">name="CLAUSE">  
    <!--
  CLAUSE   ::= Implies | ATOMIC
    -->
    <xs:choice>
      <xs:element  ref="Implies"/>ref="Implies"/>
      <xs:group  ref="ATOMIC"/>ref="ATOMIC"/>
    </xs:choice>
  </xs:group>
  
  <xs:element  name="Implies">name="Implies">
    <!--
  Implies   ::= IRIMETA? (ATOMIC | 'And' '(' ATOMIC* ')') ':-' FORMULA
    -->
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="IRIMETA" minOccurs="0" maxOccurs="1"/>ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
        <xs:element  ref="if"/>ref="if"/>
        <xs:element  ref="then"/>ref="then"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
 
  <xs:element  name="if">name="if">
    <xs:complexType>
      <xs:sequence>
        <xs:group  ref="FORMULA"/>ref="FORMULA"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
  <xs:element  name="then">name="then">
    <xs:complexType>
     <xs:choice>
       <xs:group  ref="ATOMIC"/>ref="ATOMIC"/>
       <xs:element  name="And" type="And-then.type"/>name="And" type="And-then.type"/>
     </xs:choice>
    </xs:complexType>
  </xs:element>
 
  <xs:complexType  name="And-then.type">name="And-then.type">
    <!-- sensitive to then (ATOMIC) context-->
    <xs:sequence>
      <xs:element  name="formula" type="formula-then.type" minOccurs="0" maxOccurs="unbounded"/>name="formula" type="formula-then.type" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>
 
  <xs:complexType  name="formula-then.type">name="formula-then.type">
    <!-- sensitive to then (ATOMIC) context-->
    <xs:sequence>
      <xs:group  ref="ATOMIC"/>ref="ATOMIC"/>
    </xs:sequence>
  </xs:complexType>
   
 </xs:schema>

   Type name: application

   Subtype name: rif+xml

   Required parameters: none

   Optional parameters: charset, as per RFC 3023 (XML Media Types)

   Encoding considerations: same as RFC 3023 (XML Media Types)

   Security considerations: 

       Systems which consume RIF documents are potentially vulnerable
       to attack by malicious producers of RIF documents.  The
       vulnerabilities and forms of attack are similar to those of
       other Web-based formats with programming or scripting
       capabilities, such as HTML with embedded Javascript.

       Excessive Resource Use / Denial of Service Attacks

          Full and complete processing of a RIF document, even one
          conforming to the RIF-BLD dialect, may require unlimited CPU
          and memory resources.  Through the use of  "import","import", it may
          also require arbitrary URI dereferencing, which may consume
          all available network resources on the consuming system or
          other systems.  RIF consuming systems SHOULD implement
          reasonable defenses against these attacks.

       Exploiting Implementation Flaws

          RIF is a relatively complex format, and rule engines can be
          extremely sophisticated, so it is likely that some RIF
          consuming systems will have bugs which allow specially
          constructed RIF documents to perform inappropriate
          operations. We urge RIF implementors to make systems which
          carefully anticipate and handle all possible inputs,
          including those which present syntactic or semantic errors.

       External (Application) Functions

          Because RIF may be extended with local, application defined
          datatypes and functions, arbitrary vulnerabilities may be
          introduced.  Before being installed on systems which consume
          untrusted RIF documents, these external functions should be
          closely reviewed for their own vulnerabilities and for the
          vulnerabilities that may occur when they are used in
          unexpected combinations, like  "cross-site scripting""cross-site scripting"
          attacks.
       
       In addition, as this media type uses the  "+xml""+xml" convention, it
       shares the same security considerations as other XML formats;
       see RFC 3023 (XML Media Types).


   Interoperability considerations: 

       This media type is intended to be shared with other RIF
       dialects, to be specified in the future.  Interoperation
       between the dialects is governed by the RIF specifications.

   Published specification: 

       RIF Basic Logic Dialect
       W3C Working Draft (Recommendation Track)
       http://www.w3.org/TR/rif-bld/

       This media type is intended to be shared with other RIF
       dialects, to be specified in the future.

   Applications that use this media type: 

       Unknown at the time of this draft.  Multiple applications are
       expected, however, before the specification reaches W3C
       Proposed Recommendation status.

   Additional information:

     Magic number(s): 

           As with XML in general (See RFC 3023 (XML Media Types)),
           there is no magic number for this format.

           However, the XML namespace  "http://www.w3.org/2007/rif#""http://www.w3.org/2007/rif#" will
           normally be present in the document.  It may theoretically
           be missing if the document uses XML entities in an
           obfuscatory manner.

           The hex form of that namespace will depend on the charset.
           For utf-8, the hex is: 68 74 74 70 3a 2f 2f 77 77 77 2e 77
           33 2e 6f 72.
           
     File extension(s): 

           .rif (or .xml)

     Macintosh file type code(s): 

            "TEXT""TEXT" (like other XML)

   Person & email address to contact for further information:

       Sandro Hawke, sandro@w3.org.  Please send technical comments
       and questions about RIF to public-rif-comments@w3.org, a
       mailing list with a public archive at
       http://lists.w3.org/Archives/Public/public-rif-comments/ 

   Intended usage: 

       COMMON

   Restrictions on usage: 

       None

   Author:

       The editor and contact for this media type registration is
       Sandro Hawke, sandro@w3.org.

   Change controller: 

       RIF is a product of the Rule Interchange Format (RIF) Working
       Group of the World Wide Web Consortium (W3C).  See
       http://www.w3.org/2005/rules/wg for information on the group.
       The W3C (currently acting through this working group) has
       change control over the RIF specification.



   (Any other information that the author deems interesting may be added
   below this line.)

This section summarizes the main changes to this document since the "last call" public snapshot of July 30, 2008.

• The definition of entailment in Section Logical Entailment relied on the notion of a "query document," which was not defined. The definitions in Sections Interpretation of Documents and Logical Entailment has been changed to eliminate this and related problems.
• Section EBNF Grammar for the Presentation Syntax of RIF-BLD now presents the EBNF of the entire language in one place. Previously the EBNF was given forst for the condition sublanguage and then repeated again when the entire rule language is defined.
• Numerous clarifications and explanations were added in response to the public comments.
• A number of typos were found and fixed.