BLD

From RIF
Revision as of 01:31, 16 March 2008 by Harold Boley (Talk | contribs)

Jump to: navigation, search

__NUMBEREDHEADINGS__


Document title:
RIF Basic Logic Dialect (Second Edition)
Editors
Harold Boley, National Research Council Canada
Michael Kifer, State University of New York at Stony Brook
Abstract

This document, developed by the Rule Interchange Format (RIF) Working Group, specifies a basic format that allows logic rules to be exchanged between rule-based systems.

A separate document RIF Data Types and Built-Ins describes data types and built-in functions and predicates.

Status of this Document
@@update This is an automatically generated Mediawiki page, made from some sort of W3C-style spec.

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

1 Overview

This document develops RIF-BLD (the Basic Logic Dialect of the Rule Interchange Format) based on a set of foundational concepts that are supposed to be shared by all logic-based RIF dialects.

From a theoretical perspective, RIF-BLD corresponds to the language of definite Horn rules (see Horn Logic) with equality and with a standard first-order semantics. Syntactically, RIF-BLD has a number of extensions to support features such as objects and frames a lá F-logic [KLW95], internationalized resource identifiers (or IRIs, defined by RFC 3987 [RFC-3987]) as identifiers for concepts, and XML Schema data types. In addition, the document RIF RDF and OWL Compatibility defines the syntax and semantics of integrated RIF-BLD/RDF and RIF-BLD/OWL languages. These features make RIF-BLD into a Web 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.

One important fragment of RIF is called the Condition Language. It defines the syntax and semantics for the bodies of the rules in RIF-BLD. However, it is envisioned that this fragment will have uses in other dialects of RIF. In particular, it will be used as queries, constraints, and in the conditional part in production rules (see RIF-PRD), reactive rules, and normative rules.

RIF-BLD is defined in two different ways -- both normative. First, it is defined as a specialization of the RIF Framework for Logic-based Dialects (RIF-FLD) -- the RIF extensibility framework. It is a very short description, but it requires familiarity with RIF-FLD. RIF-FLD provides a general framework -- both syntactic and semantic -- for defining RIF dialects. All logic-based dialects are required to specialize this framework. Then RIF-BLD is described independently of the RIF framework, for the benefit of those who desire a quicker path to RIF-BLD and are not interested in the extensibility issues.

The current document is the third draft of the RIF-BLD specification. A number of extensions are planned to support built-ins, additional primitive XML data types, the notion of RIF compliance, and so on. Tool support for RIF-BLD is forthcoming. RIF dialects that extend RIF-BLD in accordance with the RIF Framework for Logic Dialects will be specified in other documents by this working group.

2 RIF-BLD as a Specialization of 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-Based Dialects. The reader who is not interested in how RIF-BLD is derived from the framework can skip this section and proceed to Direct Specification of RIF-BLD Syntax.


2.1 The Syntax of RIF-BLD as a Specialization of RIF-FLD

This section defines the precise relationship between the syntax of RIF-BLD and the syntactic framework of RIF-FLD.

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


  1. Alphabet.
    • The alphabet of RIF-BLD is the alphabet of RIF-FLD with the negation symbols neg and naf excluded.
  2. Assignment of signatures to each constant symbol.
  3. The signature set of RIF-BLD contains the following signatures:

    1. Basic.
      • term{ },
      • term_builtin{ },
      • atomic{ },
      • atomic_builtin{ },
      • term_builtin<term and atomic_builtin<atomic.

      The signature term{ } represents the context in which individual objects (but not atomic formulas) can appear.
      The signature term_builtin{ } represents terms constructed with the use of builtin functions.
      The signature atomic_builtin{ } represents atomic formulas for builtin predicates (such as fn:substring).
      Since atomic_builtin<atomic, builtin atomic formulas are also atomic formulas, but normally most atomic formulas are user-defined and have the signature atomic rather than atomic_builtin.

    2. For every integer n ≥ 0, there are signatures
      • fn{(term ... term) ⇒ term} -- for n-ary function symbols,
      • pn{(term ... term) ⇒ atomic} -- for n-ary predicates,
      • fipn{(term ... term) ⇒ term_builtin} -- for n-ary builtin functions, and
      • bipn{(term ... term) ⇒ atomic_builtin} -- for n-ary builtin predicates.

      These represent function symbols of arity n, user-defined predicate symbols of arity n, and n-ary builtin predicates, respectively (each of the above cases has n terms as arguments inside the parentheses).

    3. For every set of symbols s1,...,skSigNames, there are signatures fs1...sk{(s1->term ... sk->term) ⇒ term} and ps1...sk{(s1->term ... sk->term) ⇒ atomic}. These are signatures for terms with named arguments and predicates with arguments named s1, ..., sk, respectively. Unlike in RIF-FLD, the argument names s1, ..., sk must be pairwise distinct.
    4. A symbol in Const can have exactly one signature, term, fn, pn, or bipn, where n ≥ 0, or fs1...sk{(s1->term ... sk->term) ⇒ term}, ps1...sk{(s1->term ... sk->term) ⇒ atomic}, for some s1,...,skSigNames. It cannot have the signature atomic or atomic_builtin, 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.

      Thus, in RIF-BLD each constant symbol can be either an individual, a predicate of one particular arity or with certain argument names, a builtin of one particular arity, or a function 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 supported RIF data types (XML Schema data types, rdf:XMLLiteral, rif:text) all have the signature term in RIF-BLD.
    6. The symbols of type rif:iri and rif:local can have the following signatures in RIF-BLD: term, fn, pn, or bipn, for n = 0,1,....; or fs1...sk, ps1...sk, for some argument names s1,...,skSigNames.
    7. All variables are associated with signature term{ }, so they can range only over individuals.
    8. The signature for equality is ={(term term)atomic}.

      This means that equality can compare only those terms whose signature is term; it cannot compare predicate names 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 term.

    9. The frame signature, ->, is ->{(term term term)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 #{(term term)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 ##{(term term)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 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 term, atomic, and atomic_builtin are not reserved keywords in RIF-BLD.

  4. Supported types of terms.
    • RIF-BLD supports all the term types defined by the syntactic framework (see Well-formed Terms and Formulas):
      1. constants
      2. variables
      3. positional
      4. with named arguments
      5. equality
      6. frame
      7. membership
      8. subclass
    • Compared to RIF-FLD, terms (both positional and with named arguments) have significant restrictions. This is so in order to give BLD a relatively compact nature.
      • The signature for the variable symbols does not permit them to occur in the context of predicates, functions, or formulas. In particular, unlike in RIF-FLD, a variable is not an atomic formula in RIF-BLD.
      • Likewise, a symbol cannot be an atomic formula by itself. That is, if pConst 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 term{ } and all other terms, except for the constants from Const, can have either the signature term{ } or atomic{ }. Therefore, if t is a (non-Const) term then t(...) is not a well-formed term.
  5. Supported symbol spaces.
  6. RIF-BLD supports all the symbol spaces defined in Section Symbol Spaces of the syntactic framework:

    • xsd:string
    • xsd:decimal
    • xsd:time
    • xsd:date
    • xsd:dateTime
    • rdf:XMLLiteral
    • rif:text
    • rif:iri
    • rif:local
  7. Supported formulas.
  8. RIF-BLD supports the following types of formulas (see Well-formed Terms and Formulas for the definitions):

    • RIF-BLD condition
    • A RIF-BLD condition is a conjunctive and disjunctive combination of atomic formulas with optional existential quantification of variables.

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

      • The head (or conclusion) of the rule is an atomic formula, which is not a builtin predicate (i.e., its signature is atomic, but not atomic_builtin).
      • The body (or 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)).

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

The list of supported symbol spaces will move to another document, Data Types and Built-Ins. Any existing discrepancies will be fixed at that time.


2.2 The Semantics of RIF-BLD as a Specialization of RIF-FLD

This normative section defines the precise relationship between the semantics of RIF-BLD and the semantic framework of RIF-FLD. Specification of the semantics without reference to 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 RIF-FLD in that document lists the parameters of the semantic framework, which we need to specialize for RIF-BLD.

Recall that the semantics of a dialect is derived from these notions by specializing 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.

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

  • Data types.
  • RIF-BLD supports all the data types listed in Section Primitive Data Types of RIF-FLD:

    • xsd:long
    • xsd:integer
    • xsd:decimal
    • xsd:string
    • xsd:time
    • xsd:dateTime
    • rdf:XMLLiteral
    • rif:text
  • 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 of the two following equivalent ways:

    • as a set of all models; or
    • as the unique minimal model.

    These two definitions are equivalent for entailment of RIF-BLD conditions by RIF-BLD sets of formulas, since all rules in RIF-BLD are Horn -- it is a classical result of Van Emden and Kowalski [vEK76].

The list of supported data types will move to another document, Data Types and Built-Ins. Any existing discrepancies will be fixed at that time.


3 Direct Specification of RIF-BLD Syntax

This normative section specifies the syntax of RIF-BLD directly, without referring to RIF-FLD. We define both a presentation syntax and an XML syntax. The presentation syntax is not intended to be a concrete syntax for RIF-BLD. It is defined in Mathematical English and is intended to be used in the definitions and examples. This 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.

3.1 Alphabet of RIF-BLD

Definition (Alphabet). The alphabet of RIF-BLD consists of

  • a countably infinite set of constant symbols Const,
  • a countably infinite set of variable symbols Var (disjoint from Const),
  • a countably infinite set of argument names, ArgNames (disjoint from Const and Var),
  • connective symbols And, Or, and :-,
  • quantifiers Exists and Forall,
  • the symbols =, #, ##, ->, and
  • auxiliary symbols, such as "(" and ")".

The set of connective symbols, quantifiers, =, etc., is disjoint from Const and Var. The argument names in ArgNames are written as unicode strings that must not start with a question mark, "?". Variables are written as Unicode strings preceded with the symbol "?".

Constants are written as "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 Symbol Spaces of the RIF-FLD document.   ☐

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

3.2 Terms

RIF-BLD supports several kinds of terms: constants and variables, positional terms, terms with named arguments, equality, membership, and subclass terms, and frames. The word "term" will be used to refer to any kind of terms.

Definition (Term).

  1. Constants and variables. If tConst or tVar then t is a simple term.
  2. Positional terms. If tConst and t1, ..., tn are simple, positional, or named-argument terms then t(t1 ... tn) is a positional term.
  3. Terms with named arguments. A term with named arguments is of the form t(s1->v1 ... sn->vn), where tConst and v1 , ..., vn are simple, positional, or named-argument terms and s1, ..., sn are pairwise distinct symbols from the set ArgNames.

    The term t here represents a predicate or a function; s1, ..., sn represent argument names; and v1 , ..., vn represent argument values. The argument names, s1, ..., sn, 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 both positional and with named arguments.

  4. Equality terms. If t and s are simple, positional, or named-argument terms then t = s is an equality term.
  5. Class membership terms (or just membership terms). t#s is a membership term if t and s are simple, positional, or named-argument terms.
  6. Subclass terms. t##s is a subclass term if t and s are simple, positional, or named-argument terms.
  7. Frame terms. t[p1->v1 ... pn->vn] is a frame term (or simply a frame) if t, p1, ..., pn, v1, ..., vn, n ≥ 0, are simple, positional, or named-argument terms.   ☐

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


3.3 Well-formedness of Terms

The set of all symbols, Const, is partitioned into

  • positional predicate symbols;
  • predicate symbols with named arguments;
  • positional function symbols;
  • function symbols with named arguments; and
  • individuals.

    The symbols in Const that belong to the supported RIF data types are individuals.

Each predicate and function symbol has precisely one arity.

  • For positional symbols, an arity is a non-negative integer that tells how many arguments the symbol can take.
  • For symbols that take named arguments, an arity is a set {s1 ... sk} of argument names (siArgNames), which are allowed for that symbol.

The arity of a symbol (or whether it is a predicate, a function, or an individual) is not specified explicitly in RIF-BLD. Instead, it is inferred as follows. Each constant symbol in a RIF-BLD formula (or a set of formulas) may occur in at most one context: as an individual, a function symbol of a particular arity, or a predicate symbol of a particular arity. The arity of the symbol and its type is then determined by its context. If a symbol from Const occurs in more than one context in a set of formulas, the set considered to be not well-formed in RIF-BLD.


3.4 Formulas

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. Simple terms (constants and variables) are not formulas. Not all atomic formulas are well-formed. A well-formed atomic formula is an atomic formula that is also a well-formed term (see Section Well-formedness of Terms). More general formulas are constructed out of the atomic formulas with the help of logical connectives.

Definition (Well-formed formula). A well-formed formula is a statement that has one of the following forms:

  • Atomic: If φ is a well-formed atomic formula then it is also a well-formed formula.
  • Conjunction: If φ1, ..., φn, n ≥ 0, are well-formed formulas then so is And(φ1 ... φn). As a special case, And() is allowed and is treated as a tautology, i.e., a formula that is always true.
  • Disjunction: If φ1, ..., φn, n ≥ 0, are well-formed formulas then so is Or(φ1 ... φn). When n=0, we get Or() as a special case; it is treated as a formula that is always false.
  • Existentials: If φ is a well-formed formula and ?V1, ..., ?Vn are variables then Exists ?V1 ... ?Vn(φ) is a formula.

Formulas constructed using the above definitions are called RIF-BLD conditions. The following formulas lead to the notion of a RIF-BLD rule.

  • Rule implication: If φ is an well-formed atomic formula and ψ is a RIF-BLD condition then φ :- ψ is a well-formed formula, provided that φ does not have the signature atomic_builtin (i.e., is not a builtin predicate).
  • Quantified rule: If φ is a rule implication and ?V1, ..., ?Vn are variables then Forall ?V1 ... ?Vn(φ) is a well-formed formula, called an explicitly quantified rule.

A RIF-BLD rule is a quantified rule Forall ?V1 ... ?Vn(φ) such that all the free (i.e., non-quantified) variables in φ occur in the prefix Forall ?V1 ... ?Vn.

A set of RIF-BLD rules and atomic formulas (often referred to as facts) is called a ruleset.   ☐

It can be seen from the definitions that RIF-BLD has a wide variety of syntactic forms for terms, formulas, and rules. This provides the infrastructure for exchanging rule languages that support rich collections of syntactic forms. Systems that do not support some of that syntax directly can still support it through a syntactic transformation. For instance, disjunctions in the rule body can be eliminated through a standard transformation, such as p :- Or(q r) to {p :- q,   p :- r}. Terms with named arguments can be reduced to positional terms by ordering the arguments by their names and incorporating them into the predicate name. For instance, p(bb->1 aa->2) can be represented as p_aa_bb(2,1).


3.5 EBNF Grammar for the Presentation Syntax of RIF-BLD

So far, the syntax of RIF-BLD has been specified in Mathematical English. Tool developers, however, may prefer EBNF notation, which provides a more succinct overview of the syntax. Several points should be kept in mind regarding this notation.

  • The syntax of first-order logic is not context-free, so EBNF does not 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 rules that are derivable using the EBNF grammar are well-formed rules in RIF-BLD).
  • The EBNF syntax is not a concrete syntax: it does not address the details of how constants and variables are represented, and it is not sufficiently precise about the delimiters and escape symbols. Instead, white space is informally used as a delimiter, and white space is implied in productions that use Kleene star. For instance, TERM* is to be understood as TERM TERM ... TERM, where each ' ' abstracts from one or more blanks, tabs, newlines, etc. This is done on intentionally, since RIF's presentation syntax is intended as 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 EBNF syntax.
  • For all the above reasons, the EBNF syntax is not normative.

3.5.1 EBNF for RIF-BLD Condition Language

The Condition Language represents formulas that can be used in the body of the RIF-BLD rules. It is intended to be a common part of a number of RIF dialects, including RIF PRD. The EBNF grammar for a superset of the RIF-BLD condition language is as follows.


  CONDITION      ::= 'And' '(' CONDITION* ')' |
                     'Or' '(' CONDITION* ')' |
                     'Exists' Var+ '(' CONDITION ')' |
                     ATOMIC
  ATOMIC         ::= Atom | Atomext | Equal | Member | Subclass | Frame
  Atom           ::= Const '(' (TERM* | (Const '->' TERM)*) ')'
  Atomext        ::= Const '(' TERM* ')'
  Equal          ::= TERM '=' TERM
  Member         ::= TERM '#' TERM
  Subclass       ::= TERM '##' TERM
  Frame          ::= TERM '[' (TERM '->' TERM)* ']'
  TERM           ::= Const | Var | Expr | Exprext
  Expr           ::= Const '(' (TERM* | (Const '->' TERM)*) ')'
  Exprext        ::= Const '(' TERM* ')'
  Const          ::= '"' LITERAL '"^^' SYMSPACE
  Var            ::= '?' VARNAME


The production rule for the non-terminal CONDITION 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 CONDITION. RIF-BLD conditions permit only existential variables, but RIF-FLD Syntax allows arbitrary quantification, which can be used in some dialects. A RIF-BLD CONDITION can also be an ATOMIC term, i.e. an Atom, Atomext, Equal, Member, Subclass, or Frame. A TERM can be a constant, variable, Expr, or Exprext.

The RIF-BLD presentation syntax does not commit to any particular vocabulary for the names of variables or for the literals used in constant symbols. In the examples, variables are denoted by Unicode character sequences beginning with a ?-sign. Constant symbols have the form: "LITERAL"^^SYMSPACE, where SYMSPACE is an IRI string that identifies the symbol space of the constant and LITERAL is a Unicode string from the lexical space of that symbol space. 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 Atomext (Atom with external definition) is a predicate application with positional arguments that calls a builtin predicate of RIF-DTB. Likewise, an Exprext (Expr with external definition) is a function application with positional arguments that calls a builtin function of RIF-DTB.

Example 1 shows conditions that are composed of atoms, expressions, frames, and existentials. The examples for frames show that variables can occur in the syntactic positions of object Ids, object properties, or property values. For brevity, this and other examples uses the compact URI notation [CURIE], prefix:suffix, which is a macro that expands into a concatenation of the prefix definition and suffix.


Example 1 (RIF-BLD conditions)
   Here the prefix bks is an abbreviation for http://example.com/books#,
   the prefix auth for http://example.com/authors#,
   and the prefix cpt for http://example.com/concepts#
   Positional terms:
                "cpt:book"^^rif:iri("auth:rifwg"^^rif:iri "bks:LeRif"^^rif:iri)

                Exists ?X ("cpt:book"^^rif:iri(?X "bks:LeRif"^^rif:iri))

   Terms with named arguments:
                "cpt:book"^^rif:iri("cpt:author"^^rif:iri->"auth:rifwg"^^rif:iri
                                    "cpt:title"^^rif:iri->"bks:LeRif"^^rif:iri)

                Exists ?X ("cpt:book"^^rif:iri("cpt:author"^^rif:iri->?X
                                               "cpt:title"^^rif:iri->"bks:LeRif"^^rif:iri))

   Frames:
                "bks:wd1"^^rif:iri["cpt:author"^^rif:iri->"auth:rifwg"^^rif:iri
                                  "cpt:title"^^rif:iri->"bks:LeRif"^^rif:iri ]

                Exists ?X ("bks:wd2"^^rif:iri["cpt:author"^^rif:iri->?X
                                              "cpt:title"^^rif:iri->"bks:LeRif"^^rif:iri ])

                Exists ?X ("bks:wd2"^^rif:iri # "cpt:book"^^rif:iri["cpt:author"^^rif:iri->?X
                                                                    "cpt:title"^^rif:iri->"bks:LeRif"^^rif:iri])

                Exists ?I ?X (?I["cpt:author"^^rif:iri->?X
                                 "cpt:title"^^rif:iri->"bks:LeRif"^^rif:iri])

                Exists ?I ?X (?I # "cpt:book"^^rif:iri["cpt:author"^^rif:iri->?X
                                                       "cpt:title"^^rif:iri->"bks:LeRif"^^rif:iri])

                Exists ?S ("bks:wd2"^^rif:iri["cpt:author"^^rif:iri->"auth:rifwg"^^rif:iri
                                              ?S->"bks:LeRif"^^rif:iri])

                Exists ?X ?S ("bks:wd2"^^rif:iri["cpt:author"^^rif:iri->?X
                                                 ?S->"bks:LeRif"^^rif:iri])

                Exists ?I ?X ?S (?I # "cpt:book"^^rif:iri[author->?X
                                                          ?S->"bks:LeRif"^^rif:iri])


3.5.2 EBNF for RIF-BLD Rule Language

The presentation syntax for Horn rules extends the syntax in Section EBNF for RIF-BLD Condition Language with the following productions.


  Ruleset  ::= RULE*
  RULE     ::= 'Forall' Var+ '(' RULE ')' | Implies | HEAD
  HEAD     ::= Atom | Equal | Frame
  Implies  ::= HEAD ':-' CONDITION


A Ruleset is a set of RIF rules. Rules are generated by the Implies production and Forall-quantification. All free (non-quantified) variables in RULE must occur in Var. Var, Atom, Equal, Frame, and CONDITION were defined as part of the syntax for positive conditions in Section EBNF for RIF-BLD Condition Language. In the RULE production a HEAD is treated as a rule with an empty condition part -- in which case it is usually called a fact. Note that, by a definition in Section Formulas, atomic formulas that correspond to builtin predicates (i.e., formulas with signature atomic_builtin) are not allowed in the conclusion part of a rule (HEAD does not expand to Atomext ).

The following example shows a business rule borrowed from the document RIF Use Cases and Requirements.


Example 2 (RIF-BLD rules)
  Rule: 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.
    Here the prefix ppl is an abbreviation for http://example.com/people#,
    the prefix cpt for http://example.com/concepts#,
    and op stands for a yet-to-be-determined IRI for RIF builtin predicates.
a. Universal form:

  Forall ?item ?deliverydate ?scheduledate ?diffduration ?diffdays (
       "cpt:reject"^^rif:iri("ppl:John"^^rif:iri ?item) :-
           And("cpt:perishable"^^rif:iri(?item)
               "cpt:delivered"^^rif:iri(?item ?deliverydate "ppl:John"^^rif:iri)
               "cpt:scheduled"^^rif:iri(?item ?scheduledate)
               "fn:subtract-dateTimes-yielding-dayTimeDuration"^^rif:iri(?deliverydate ?scheduledate ?diffduration)
               "fn:get-days-from-dayTimeDuration"^^rif:iri(?diffduration ?diffdays)
               "op:numeric-greater-than"^^rif:iri(?diffdays "10"^^xsd:integer))
  )

b. Universal-existential form:

  Forall ?item (
       "cpt:reject"^^rif:iri("ppl:John"^^rif:iri ?item ) :-
           Exists ?deliverydate ?scheduledate ?diffduration ?diffdays (
                And("cpt:perishable"^^rif:iri(?item)
                    "cpt:delivered"^^rif:iri(?item ?deliverydate "ppl:John"^^rif:iri)
                    "cpt:scheduled"^^rif:iri(?item ?scheduledate)
                    "fn:subtract-dateTimes-yielding-dayTimeDuration"^^rif:iri(?deliverydate ?scheduledate ?diffduration)
                    "fn:get-days-from-dayTimeDuration"^^rif:iri(?diffduration ?diffdays)
                    "op:numeric-greater-than"^^rif:iri(?diffdays "10"^^xsd:integer))
           )
  )


4 Direct Specification of RIF-BLD Semantics

This normative section specifies the semantics of RIF-BLD directly, without referring to RIF-FLD.

4.1 Truth Values

The set TV of truth values in RIF-BLD consists of just two values, t and f.

4.2 Semantic Structures

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

Definition (Semantic structure). A semantic structure, I, is a tuple of the form <TV, DTS, D, Dind, Dfunc, IC, IV, IF, Iframe, ISF, Isub, Iisa, I=, ITruth>. Here D is a non-empty set of elements called the domain of I, and Dind, Dfunc are nonempty subsets of D. Dind is used to interpret the elements of Const, which denote individuals and Dfunc is used to interpret the elements of Const that denote 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 the set of primitive data types used in I (please refer to Section Primitive Data Types of RIF-FLD for the semantics of data types).

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, denotes an individual then it is required that IC(c) ∈ Dind.
    • If c ∈ Const, denotes a function symbol (positional or with named arguments) then it is required that IC(c) ∈ Dfunc.
  2. IV maps Var to Dind.

    This mapping interprets variable symbols.

  3. IF maps D to functions D*indD (here D*ind is a set of all sequences of any finite length over the domain Dind)

    This mapping interprets positional terms. In addition:

    • If dDfunc then IF(d) must be a function D*indDind.
    • This means that when a function symbol is applied to arguments that are individual object then the result is also an individual object.
  4. ISF is a total mapping from D to the set of total functions of the form SetOfFiniteSets(ArgNames × Dind) → D.

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

    • If dDfunc then ISF(d) must be a function SetOfFiniteSets(ArgNames × Dind) → Dind.
    • This is analogous to the interpretation of positional terms with two differences:
      • Each pair <s,v>ArgNames × Dind represents a 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. Iframe is a total mapping from Dind to total functions of the form SetOfFiniteBags(Dind × Dind) → D.

    This mapping interprets frame terms. An argument, dDind, to Iframe represent an object and the finite bag {<a1,v1>, ..., <ak,vk>} represents a bag of attribute-value pairs for d. We will see shortly how Iframe 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]. Such repetitions arise naturally when variables are instantiated with constants. For instance, o[?A->?B ?A->?B] becomes o[a->b a->b] if variable ?A is instantiated with the symbol a and ?B with b.

  6. Isub gives meaning to the subclass relationship. It is a total function Dind × DindD.

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

  7. Iisa gives meaning to class membership. It is a total function Dind × DindD.

    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 # cl and cl ## scl must imply o # scl. This is ensured by a restriction in Section Interpretation of Formulas.

  8. I= is a total function Dind × DindD.

    It gives meaning to the equality operator.

  9. ITruth is a total mapping DTV.

    It is used to define truth valuation of formulas.

We also define the following mapping I from terms to D:

  • I(k) = IC(k), if k is a symbol in Const
  • I(?v) = IV(?v), if ?v is a variable in Var
  • I(f(t1 ... tn)) = IF(I(f))(I(t1),...,I(tn))
  • I(f(s1->v1 ... sn->vn)) = ISF(I(f))({<s1,I(v1)>,...,<sn,I(vn)>})
  • Here we use {...} to denote a set of argument/value pairs.

  • I(o[a1->v1 ... ak->vk]) = Iframe(I(o))({<I(a1),I(v1)>, ..., <I(an),I(vn)>})
  • Here {...} denotes a bag of attribute/value pairs.

  • I(c1##c2) = Isub(I(c1), I(c2))
  • I(o#c) = Iisa(I(o), I(c))
  • I(x=y) = I=(I(x), I(y))

The effect of data types. The data types in DTS impose the following restrictions. If dt is a symbol space identifier of a data type, let LSdt denote the lexical space of dt, VSdt denote its value space, and Ldt: LSdtVSdt the lexical-to-value-space mapping (for the definitions of these concepts, see Section Primitive Data Types of RIF-FLD). Then the following must hold:

  • VSdtDind; and
  • For each constant "lit"^^dtLSdt, IC("lit"^^dt) = Ldt(lit).

That is, IC must map the constants of a data type dt in accordance with Ldt.

RIF-BLD does not impose restrictions on IC for constants in the lexical spaces that do not correspond to primitive datatypes in DTS.   ☐

4.3 Interpretation of Formulas

Definition (Truth valuation). Truth valuation for well-formed formulas in RIF-BLD is determined using the following function, denoted TValI:

  1. Positional atomic formulas: TValI(r(t1 ... tn)) = ITruth(I(r(t1 ... tn)))
  2. Atomic formulas with named arguments: TValI(p(s1->v1 ... sk->vk)) = ITruth(I(p(s1-> v1 ... sk->vk))).
  3. Equality: TValI(x = y) = ITruth(I(x = y)).
    • To ensure that equality has precisely the expected properties, it is required that:
        ITruth(I(x = y)) = t if and only if I(x) = I(y) and that ITruth(I(x = y)) = f otherwise.
    • This is tantamount to saying that TValI(x = y) = t if I(x) = I(y).
  4. Subclass: TValI(sc ## cl) = ITruth(I(sc ## cl)).

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

      For all c1, c2, c3D,   if TValI(c1 ## c2) = TValI(c2 ## c3) = t   then TValI(c1 ## c3) = t.

  5. Membership: TValI(o # cl) = ITruth(I(o # cl)).

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

      For all o, cl, sclD,   if TValI(o # cl) = TValI(cl ## scl) = t   then   TValI(o # scl) = t.

  6. Frame: TValI(o[a1->v1 ... ak->vk]) = ITruth(I(o[a1->v1 ... ak->vk])).

    Since the different attribute/value pairs are supposed to be understood as conjunctions, the following is required:

      TValI(o[a1->v1 ... ak->vk]) = t if and only if TValI(o[a1->v1]) = ... = TValI(o[ak->vk]) = t.

  7. Conjunction: TValI(And(c1 ... cn)) = t if and only if TValI(c1) = ... = TValI(cn) = t. Otherwise, TValI(And(c1 ... cn)) = f.
  8. Disjunction: TValI(Or(c1 ... cn)) = f if and only if TValI(c1) = ... = TValI(cn) = f. Otherwise, TValI(Or(c1 ... cn)) = t.
  9. Quantification:
    • TValI(Exists ?v1 ... ?vn (φ)) = t if and only if for some I*, described below, TValI*(φ) = t.
    • TValI(Forall ?v1 ... ?vn (φ)) = t if and only if for every I*, described below, TValI*(φ) = t.

    Here I* is a semantic structure of the form <TV, DTS, D, Dind, Dfunc, IC, I*V, IF, Iframe, ISF, Isub, Iisa, ITruth>, which is exactly like I, except that the mapping I*V, is used instead of IV.   I*V is defined to coincide with IV on all variables except, possibly, on ?v1,...,?vn.

  10. Rule implication:
    • TValI(conclusion :- condition) = t, if either TValI(conclusion)=t or TValI(condition)=f.
    • TValI(conclusion :- condition) = f   otherwise.

A model of a set Ψ of formulas is a semantic structure I such that TValI(φ) = t   for every   φ∈Ψ. In this case, we write I |= Ψ.   ☐

4.4 Logical Entailment

We now define what it means for a set of RIF-BLD rules to entail a RIF-BLD condition.

A RIF-BLD condition formula φ is existentially closed, if and only if every variable, ?V, in φ occurs in a subformula of the form Exists ...?V...(ψ).

Definition (Logical entailment). Let R be a set of RIF-BLD rules and φ an existentially closed RIF-BLD condition formula. We say that R entails φ, written as R |= φ, if and only if for every semantic structure I of R and every ψ ∈ R, it is the case that if TValI(ψ) = t then TValI(φ) = t.

Equivalently, we can say that R |= φ holds iff whenever I |= R it follows that also I |= φ.   ☐


5 XML Serialization Syntax for RIF-BLD

The XML serialization for RIF-BLD given in this section is alternating or fully striped (e.g., [ANF01]). Positional information is optionally exploited only for the arg role elements. For example, role elements (declare and formula) are explicit within the Exists element. Following the examples of Java and RDF, we use capitalized names for class elements and names that start with lowercase for role elements.

The all-uppercase classes in the presentation syntax, such as CONDITION, become XML entities. They act like macros and 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.

5.1 XML for RIF-BLD Condition Language

We now serialize the syntax of Section EBNF for RIF-BLD Condition Language in XML.


Classes, roles and their intended meaning

- 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 CONDITION formula)
- Atom      (atom formula, positional or with named arguments)
- Atomext   (atom formula, positional, for external builtin predicate calls)
- 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)
- arg       (argument role)
- upper     (Member/Subclass upper class role)
- lower     (Member/Subclass lower instance/class role)
- slot      (Atom/Expr/Frame slot role, prefix version of slot infix ' -> ')
- Equal     (prefix version of term equation '=')
- Expr      (expression formula, positional or with named arguments)
- Exprext   (expression formula, positional, for external builtin function calls)
- side      (Equal left-hand side and right-hand side role)
- Const     (slot, individual, function, or predicate symbol, with optional 'type' attribute)
- Var       (logic variable)


For the XML Schema Definition (XSD) of the RIF-BLD condition language see Appendix XML Schema for BLD.

The XML syntax for symbol spaces utilizes the type attribute associated with XML term elements such as Const. For instance, a literal in the xsd:dateTime data type can be represented as <Const type="xsd:dateTime">2007-11-23T03:55:44-02:30</Const>.

The following example illustrates XML serialization of RIF conditions.


Example 3 (A RIF condition and its XML serialization):
  Here the prefix bks is an abbreviation for http://example.com/books#,
  cpt for http://example.com/concepts#,
  and curr for http://example.com/currencies#
a. RIF condition

  And (Exists ?Buyer ("cpt:purchase"^^rif:iri(?Buyer
                                              ?Seller
                                              "cpt:book"^^rif:iri(?Author "bks:LeRif"^^rif:iri)
                                              "curr:USD"^^rif:iri ("49"^^xsd:integer)))
       ?Seller=?Author )

b. XML serialization

  <And>
    <formula>
      <Exists>
        <declare><Var>Buyer</Var></declare>
        <formula>
          <Atom>
            <op><Const type="rif:iri">cpt:purchase</Const></op>
            <arg><Var>Buyer</Var></arg>
            <arg><Var>Seller</Var></arg>
            <arg>
              <Expr>
                <op><Const type="rif:iri">cpt:book</Const></op>
                <arg><Var>Author</Var></arg>
                <arg><Const type="rif:iri">bks:LeRif</Const></arg>
              </Expr>
            </arg>
            <arg>
              <Expr>
                <op><Const type="rif:iri">curr:USD</Const></op>
                <arg><Const type="xsd:integer">49</Const></arg>
              </Expr>
            </arg>
          </Atom>
        </formula>
      </Exists>
    </formula>
    <formula>
      <Equal>
        <side><Var>Seller</Var></side>
        <side><Var>Author</Var></side>
      </Equal>
    </formula>
  </And>


The following example illustrates XML serialization of RIF conditions that involve terms with named arguments.


Example 4 (A RIF condition and its XML serialization):
   The prefix bks is an abbreviation for http://example.com/books#,
   the prefix auth for http://example.com/authors#,
   the prefix cpt for http://example.com/concepts#, and
   curr for http://example.com/currencies#.
a. RIF condition:

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

b. XML serialization:

  <And>
    <formula>
      <Exists>
        <declare><Var>Buyer</Var></declare>
        <declare><Var>P</Var></declare>
        <formula>
          <Frame>
            <object>
              <Member>
                <lower><Var>P</Var></lower>
                <upper><Const type="rif:iri">cpt:purchase</Const></upper>
              </Member>
            </object>
            <slot><Const type="rif:iri">cpt:buyer</Const><Var>Buyer</Var></slot>
            <slot><Const type="rif:iri">cpt:seller</Const><Var>Seller</Var></slot>
            <slot>
              <Const type="rif:iri">cpt:item</Const>
              <Expr>
                <op><Const type="rif:iri">cpt:book</Const></op>
                <slot><Const type="rif:iri">cpt:author</Const><Var>Author</Var></slot>
                <slot><Const type="rif:iri">cpt:title</Const><Const type="rif:iri">bks:LeRif</Const></slot>
              </Expr>
            </slot>
            <slot><Const type="rif:iri">cpt:price</Const><Const type="xsd:integer">49</Const></slot>
            <slot><Const type="rif:iri">cpt:currency</Const><Const type="rif:iri">curr:USD</Const></slot>
          </Frame>
        </formula>
      </Exists>
    </formula>
    <formula>
      <Equal>
        <side><Var>Seller</Var></side>
        <side><Var>Author</Var></side>
      </Equal>
    </formula>
  </And>


5.2 XML for RIF-BLD Rule Language

The following extends the XML syntax in Section XML for RIF-BLD Condition Language, by serializing the syntax of Section EBNF for RIF-BLD Rule Language in XML. The Forall element contains the role elements declare and formula, which were earlier used within the Exists element in Section XML for RIF-BLD Condition Language. The Implies element contains the role elements if and then to designate these two parts of a rule.


Classes, roles and their intended meaning

- Ruleset (rule collection, containing rule roles)
- rule    (rule role, containing rule)
- Forall  (quantified formula for 'Forall', containing declare and formula roles)
- Implies (implication, containing if and then roles)
- if      (antecedent role, containing CONDITION)
- then    (consequent role, containing HEAD)


For the XML Schema Definition (XSD) of the RIF-BLD Horn rule language see Appendix XML Schema for BLD.

For instance, the rule in Example 5a can be serialized in XML as shown below as the first element of a ruleset whose second element is a business rule for Fred.


Example 5 (A RIF ruleset in XML syntax)
<Ruleset>
 <rule>
  <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>
                <arg><Var>item</Var></arg>
              </Atom>
            </formula>
            <formula>
              <Atom>
                <op><Const type="rif:iri">cpt:delivered</Const></op>
                <arg><Var>item</Var></arg>
                <arg><Var>deliverydate</Var></arg>
                <arg><Const type="rif:iri">ppl:John</Const></arg>
              </Atom>
            </formula>
            <formula>
              <Atom>
                <op><Const type="rif:iri">cpt:scheduled</Const></op>
                <arg><Var>item</Var></arg>
                <arg><Var>scheduledate</Var></arg>
              </Atom>
            </formula>
            <formula>
              <Atom>
                <op><Const type="rif:iri">fn:subtract-dateTimes-yielding-dayTimeDuration</Const></op>
                <arg><Var>deliverydate</Var></arg>
                <arg><Var>scheduledate</Var></arg>
                <arg><Var>diffduration</Var></arg>
              </Atom>
            </formula>
            <formula>
              <Atom>
                <op><Const type="rif:iri">fn:get-days-from-dayTimeDuration</Const></op>
                <arg><Var>diffduration</Var></arg>
                <arg><Var>diffdays</Var></arg>
              </Atom>
            </formula>
            <formula>
              <Atomext>
                <op><Const type="rif:iri">op:numeric-greater-than</Const></op>
                <arg><Var>diffdays</Var></arg>
                <arg><Const type="xsd:long">10</Const></arg>
              </Atomext>
            </formula>
          </And>
        </if>
        <then>
          <Atom>
            <op><Const type="xsd:long">reject</Const></op>
            <arg><Const type="rif:iri">ppl:John</Const></arg>
            <arg><Var>item</Var></arg>
          </Atom>
        </then>
      </Implies>
    </formula>
  </Forall>
 </rule>
 <rule>
  <Forall>
    <declare><Var>item</Var></declare>
    <formula>
      <Implies>
        <if>
          <Atom>
            <op><Const type="rif:iri">cpt:unsolicited</Const></op>
            <arg><Var>item</Var></arg>
          </Atom>
        </if>
        <then>
          <Atom>
            <op><Const type="rif:iri">cpt:reject</Const></op>
            <arg><Const type="rif:iri">ppl:Fred</Const></arg>
            <arg><Var>item</Var></arg>
          </Atom>
        </then>
      </Implies>
    </formula>
  </Forall>
 </rule>
</Ruleset>


5.3 Translation Between the RIF-BLD Presentation and XML Syntaxes

We now show how to translate between the presentation and XML syntaxes of RIF-BLD.

5.3.1 Translation of RIF-BLD Condition Language

The translation between the presentation syntax and the XML syntax of the RIF-BLD Condition Language is given by a table as follows. This translation makes use of RIF-BLD signatures where it is understood that pred applications are associated with atomic{ }, predext applications with atomic_builtin{ }, func applications with term{ }, and funcext applications with term_builtin{ }.

Presentation Syntax XML Syntax
And (
  conjunct1
  . . .
  conjunctn
    )
<And>
  <formula>conjunct1</formula>
   . . .
  <formula>conjunctn</formula>
</And>
Or (
  disjunct1
  . . .
  disjunctn
   )
<Or>
  <formula>disjunct1</formula>
   . . .
  <formula>disjunctn</formula>
</Or>
Exists
  variable1
  . . .
  variablen (
             body
             )
<Exists>
  <declare>variable1</declare>
   . . .
  <declare>variablen</declare>
  <formula>body</formula>
</Exists>
pred (
  argument1
  . . .
  argumentn
          )
<Atom>
  <op>pred</op>
  <arg>argument1</arg>
   . . .
  <arg> argumentn</arg>
</Atom>
predext (
  argument1
  . . .
  argumentn
          )
<Atomext>
  <op>predext</op>
  <arg>argument1</arg>
   . . .
  <arg> argumentn</arg>
</Atomext>
func (
  argument1
  . . .
  argumentn
          )
<Expr>
  <op>func</op>
  <arg>argument1</arg>
   . . .
  <arg> argumentn</arg>
</Expr>
funcext (
  argument1
  . . .
  argumentn
          )
<Exprext>
  <op>funcext</op>
  <arg>argument1</arg>
   . . .
  <arg> argumentn</arg>
</Exprext>
pred (
  key1 -> filler1
  . . .
  keyn -> fillern
         )
<Atom>
  <op>pred</op>
  <slot>key1 filler1</slot>
   . . .
  <slot>keyn fillern</slot>
</Atom>
func (
  key1 -> filler1
  . . .
  keyn -> fillern
         )
<Expr>
  <op>func</op>
  <slot>key1 filler1</slot>
   . . .
  <slot>keyn fillern</slot>
</Expr>
inst [
  key1 -> filler1
  . . .
  keyn -> fillern
     ]
<Frame>
  <object>inst</object>
  <slot>key1 filler1</slot>
   . . .
  <slot>keyn fillern</slot>
</Frame>
inst # class [
  key1 -> filler1
  . . .
  keyn -> fillern
             ]
<Frame>
  <object>
    <Member>
      <lower>inst</lower>
      <upper>class</upper>
    </Member>
  </object>
  <slot>key1 filler1</slot>
   . . .
  <slot>keyn fillern</slot>
</Frame>
sub ## super [
  key1 -> filler1
  . . .
  keyn -> fillern
             ]
<Frame>
  <object>
    <Subclass>
      <lower>sub</lower>
      <upper>super</upper>
    </Subclass>
  </object>
  <slot>key1 filler1</slot>
   . . .
  <slot>keyn fillern</slot>
</Frame>
inst # class
<Member>
  <lower>inst</lower>
  <upper>class</upper>
</Member>
sub ## super
<Subclass>
  <lower>sub</lower>
  <upper>super</upper>
</Subclass>
left = right
<Equal>
  <side>left</side>
  <side>right</side>
</Equal>
name^^space
<Const type="space">name</Const>
?name
<Var>name</Var>


5.3.2 Translation of RIF-BLD Rule Language

The translation between the presentation syntax and the XML syntax of the RIF-BLD Rule Language is given by a table that extends the translation table of Section Translation of RIF-BLD Condition Language as follows.


Presentation Syntax XML Syntax
Ruleset (
  clause1
   . . .
  clausen
        )
<Ruleset>
  <rule>clause1</rule>
   . . .
  <rule>clausen</rule>
</Ruleset>
Forall
  variable1
  . . .
  variablen (
             rule
            )
<Forall>
  <declare>variable1</declare>
   . . .
  <declare>variablen</declare>
  <formula>rule</formula>
</Forall>
conclusion :- condition
<Implies>
  <if>condition</if>
  <then>conclusion</then>
</Implies>


6 References

6.1 Normative References

[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/.

[RDF-SEMANTICS]
RDF Semantics, Patrick Hayes, Editor, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-mt-20040210/. Latest version available at http://www.w3.org/TR/rdf-mt/.

[RDF-SCHEMA]
RDF Vocabulary Description Language 1.0: RDF Schema, Brian McBride, Editor, W3C Recommendation 10 February 2004, http://www.w3.org/TR/rdf-schema/.

[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.

[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/.

6.2 Informational References

[ANF01]
Normal Form Conventions for XML Representations of Structured Data, Henry S. Thompson. October 2001.

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

[CKW93]
HiLog: A Foundation for higher-order logic programming, W. Chen, M. Kifer, D.S. Warren. Journal of Logic Programming, vol. 15, no. 3, February 1993, pp. 187--230.

[CK95]
Sorted HiLog: Sorts in Higher-Order Logic Data Languages, W. Chen, M. Kifer. Sixth Intl. Conference on Database Theory, Prague, Czech Republic, January 1995, Lecture Notes in Computer Science 893, Springer Verlag, pp. 252--265.

[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/.

[Shoham87]
Nonmonotonic logics: meaning and utility, Y. Shoham. Proc. 10th International Joint Conference on Artificial Intelligence, Morgan Kaufmann, pp. 388--393, 1987.

[CURIE]
CURIE Syntax 1.0: A compact syntax for expressing URIs, Mark Birbeck. Draft, 2005. Available at http://www.w3.org/2001/sw/BestPractices/HTML/2005-10-27-CURIE.

[FL2]
FLORA-2: An Object-Oriented Knowledge Base Language, M. Kifer. Web site. Available at http://flora.sourceforge.net.

[OOjD]
Object-Oriented jDREW, Web site. Available at http://www.jdrew.org/oojdrew/.

[GRS91]
The Well-Founded Semantics for General Logic Programs, A. Van Gelder, K.A. Ross, J.S. Schlipf. Journal of ACM, 38:3, pages 620-650, 1991.

[GL88]
The Stable Model Semantics for Logic Programming, M. Gelfond and V. Lifschitz. Logic Programming: Proceedings of the Fifth Conference and Symposium, pages 1070-1080, 1988.

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


7 Appendix: Subdialects of RIF-BLD

The following is a proposal, under discussion, for specifying RIF-CORE and some other subdialects of BLD by removing certain syntactic constructs from RIF-BLD and the corresponding restrictions on the semantics (hence, by further specializing RIF-BLD). For some engines it might be preferable or more natural to support only some subdialects of RIF-BLD. These subdialects of BLD can also be reused in the definitions of other RIF dialects.

The syntactic structure of RIF-BLD suggests several useful subdialects:

  • RIF-CORE. This subdialect is obtained from RIF-BLD by removing support for:
    • equality formulas in the rule conclusions (while still allowing them in conditions)
    • terms with named arguments
    • membership, subclass, and frame terms
  • RIF-CORE+equality.
    • This subdialect extends RIF-CORE by adding support for equality formulas in the rule conclusions.
  • RIF-CORE+named arguments.
    • This subdialect extends RIF-CORE by adding syntactic support for terms with named arguments.


8 Appendix: XML Schema for RIF-BLD

The namespace of RIF is http://www.w3.org/2007/rif#.

XML schemas for the RIF-BLD sublanguages are available below and http://www.jdrew.org/rif/wd2/ online, with examples.


Uniterm still to be split here into Atom and Expr.


8.1 Condition Language

<?xml 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: BLDCond.xsd,v 0.7 2008-02-12 dhirtle/hboley">

  <xs:annotation>
    <xs:documentation>
    This is the XML schema for the Condition Language as defined by
    Working Draft 2 of the RIF Basic Logic Dialect.

    The schema is based on the following EBNF for the RIF-BLD Condition Language:

  CONDITION      ::= 'And' '(' CONDITION* ')' |
                     'Or' '(' CONDITION* ')' |
                     'Exists' Var+ '(' CONDITION ')' |
                     COMPOUND
  COMPOUND       ::= Uniterm | Equal | Member | Subclass | Frame
  Uniterm        ::= Const '(' (TERM* | (Const '->' TERM)*) ')'
  Equal          ::= TERM '=' TERM
  Member         ::= TERM '#' TERM
  Subclass       ::= TERM '##' TERM
  Frame          ::= TERM '[' (TERM '->' TERM)* ']'
  TERM           ::= Const | Var | COMPOUND
  Const          ::= '"' LITERAL '"^^' SYMSPACE
  Var            ::= '?' VARNAME
    </xs:documentation>
  </xs:annotation>

  <xs:group name="CONDITION">
    <!--
  CONDITION      ::= 'And' '(' CONDITION* ')' |
                     'Or' '(' CONDITION* ')' |
                     'Exists' Var+ '(' CONDITION ')' |
                     COMPOUND
    -->
    <xs:choice>
      <xs:element ref="And"/>
      <xs:element ref="Or"/>
      <xs:element ref="Exists"/>
      <xs:group ref="COMPOUND"/>
    </xs:choice>
  </xs:group>

  <xs:element name="And">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="formula" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="Or">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="formula" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="Exists">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="declare" minOccurs="1" maxOccurs="unbounded"/>
        <xs:element ref="formula"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="formula">
    <xs:complexType>
      <xs:sequence>
        <xs:group ref="CONDITION"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="declare">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="Var"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:group name="COMPOUND">
    <!--
  COMPOUND       ::= Uniterm | Equal | Member | Subclass | Frame
    -->
    <xs:choice>
      <xs:element ref="Uniterm"/>
      <xs:element ref="Equal"/>
      <xs:element ref="Member"/>
      <xs:element ref="Subclass"/>
      <xs:element ref="Frame"/>
    </xs:choice>
  </xs:group>

  <xs:element name="Uniterm">
    <!--
  Uniterm        ::= Const '(' (TERM* | (Const '->' TERM)*) ')'
    -->
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="op"/>
        <xs:choice>
          <xs:element ref="arg" minOccurs="0" maxOccurs="unbounded"/>
          <xs:element ref="slot" minOccurs="0" maxOccurs="unbounded"/>
        </xs:choice>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="op">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="Const"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="arg">
    <xs:complexType>
      <xs:sequence>
        <xs:group ref="TERM"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="slot">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="Const"/>
        <xs:group ref="TERM"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="Equal">
    <!--
    Equal          ::= TERM '=' TERM
    -->
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="side"/>
        <xs:element ref="side"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="side">
    <xs:complexType>
      <xs:sequence>
        <xs:group ref="TERM"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="Member">
    <!--
  Member         ::= TERM '#' TERM
    -->
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="lower"/>
        <xs:element ref="upper"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="Subclass">
    <!--
  Subclass       ::= TERM '##' TERM
    -->
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="lower"/>
        <xs:element ref="upper"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="lower">
    <xs:complexType>
      <xs:sequence>
        <xs:group ref="TERM"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="upper">
    <xs:complexType>
      <xs:sequence>
        <xs:group ref="TERM"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="Frame">
    <!--
  Frame          ::= TERM '[' (TERM '->' TERM)* ']'
    -->
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="object"/>
        <xs:element name="slot" minOccurs="0" maxOccurs="unbounded">
          <!-- note difference from slot in Uniterm -->
          <xs:complexType>
            <xs:sequence>
              <xs:group ref="TERM"/>
              <xs:group ref="TERM"/>
            </xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="object">
    <xs:complexType>
      <xs:sequence>
        <xs:group ref="TERM"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:group name="TERM">
    <!--
  TERM           ::= Const | Var | COMPOUND
    -->
      <xs:choice>
         <xs:element ref="Const"/>
         <xs:element ref="Var"/>
         <xs:group ref="COMPOUND"/>
      </xs:choice>
  </xs:group>

  <xs:element name="Const">
    <!--
    Const       ::= '"' LITERAL '"^^' SYMSPACE
    -->
    <xs:complexType mixed="true">
      <xs:sequence/>
      <xs:attribute name="type" type="xs:string" use="required"/>
    </xs:complexType>
  </xs:element>

  <xs:element name="Var" type="xs:string">
    <!--
    Var         ::= '?' VARNAME
    -->
  </xs:element>

</xs:schema>


8.2 Rule Language

<?xml 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: BLDRule.xsd,v 0.7 2008-02-12 dhirtle/hboley">

  <xs:annotation>
    <xs:documentation>
    This is the XML schema for the Rule Language as defined by
    Working Draft 2 of the RIF Basic Logic Dialect.

    The schema is based on the following EBNF for the RIF-BLD Rule Language:

  Document ::= Ruleset*
  Ruleset  ::= RULE*
  RULE     ::= 'Forall' Var+ '(' RULE ')' | Implies | COMPOUND
  Implies  ::= COMPOUND ':-' CONDITION

    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-->
  <xs:include schemaLocation="BLDCond.xsd"/>

  <xs:element name="Document">
    <!--
    Document ::= Ruleset*
    -->
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="Ruleset" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="Ruleset">
    <!--
    Ruleset  ::= RULE*
    -->
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="rule" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="rule">
    <xs:complexType>
      <xs:sequence>
        <xs:group ref="RULE"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:group name="RULE">
  <!--
  RULE     ::= 'Forall' Var+ '(' RULE ')' | Implies | COMPOUND
  -->
    <xs:choice>
      <xs:element ref="Forall"/>
      <xs:element ref="Implies"/>
      <xs:group ref="COMPOUND"/>
    </xs:choice>
  </xs:group>

  <xs:element name="Forall">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="declare" minOccurs="1" maxOccurs="unbounded"/>
        <!-- note different from formula in And, Or and Exists -->
        <xs:element name="formula">
          <xs:complexType>
            <xs:group ref="RULE"/>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="Implies">
    <!--
  Implies  ::= COMPOUND ':-' CONDITION
    -->
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="if"/>
        <xs:element ref="then"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="if">
    <xs:complexType>
      <xs:sequence>
        <xs:group ref="CONDITION"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:element name="then">
    <xs:complexType>
      <xs:sequence>
        <xs:group ref="COMPOUND"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

</xs:schema>