FOL RuleML: The First-Order Logic Web Language

First-Order Logic RuleML (FOL RuleML) is introduced here as a language for the First-Order Logic Web on the basis of combining Quantifier RuleML and Disjunctive RuleML. This sublanguage combination is then enriched by further connectives, notably by classical negation, for achieving FOL RuleML. The markup language for first-order logic introduced here is itself proposed as a central RuleML sublanguage, extending the design of RuleML 0.87. It will also benefit other sublanguages towards RuleML 0.9, such as the current Horn logic markup.

A notion of 'query' will be used in this paper that corresponds to what has often been named 'goal' in the AI literature. A query in this sense encompasses a formula that can be proved either by direct retrieval or by a general (here, FOL) deduction (in FOL not necessarily based on ultimate direct retrievals). Other work on query languages has focussed on retrieval, and has generalized complementary aspects such as the expressiveness of query patterns, aggregates, etc. In particular, the W3C RDF Data Access Working Group is defining generalized retrieval through multiple-valued graph pattern matching. It will be interesting to see how this could be simulated by, or combined with, the FOL queries discussed here. Another connection with W3C's DAWG is RuleML's striped syntax, motived by RDF, which in this paper will be carried over to FOL RuleML, and will be abridged via StripeSkipping.

Explicit quantifiers, 'Forall' and 'Exists', are now optionally provided for FOL purposes. These quantifiers have been requested by RuleML participants as well as SWRL observers including Drew McDermott, and are essential for all full FOL languages such as DRS, SCL, and FOL RuleML. We will also optionally provide an abbreviation syntax for regarding certain free variables as universally quantified variables, which is more explicit than the convention of Prolog/LP and many other (theorem-proving) systems: A 'closure' attribute on clauses can be set to "universal" (or "existential"); similarly, for entire rulebases.

In the spirit of the logic in 'FOL RuleML', the conjoined clauses of a rulebase are connected by an explicit 'And'. FOL RuleML also allows a corresponding 'Or', for disjoined clauses. Either of these parent connectives can have attributes for expressing properties of contained clauses. In particular, the free-variable convention of the clausal normal form in theorem provers is expressed explicitly by the attribute setting innerclose="universal", universally closing off clauses occurring as subformulas in the parent 'And'/'Or', i.e. acting as if all of its contained clauses would have the attribute setting closure="universal".

RuleML 0.87 top-level elements ('Imp', 'Fact', and -- still -- 'Query') -- directly below a rulebase -- can contain extra information such as a rule label (also planned: a rule salience etc.). This information is now also offered for sublevel elements, e.g. to refer to the elements of a local rulebase. We can thus avoid a top-level/sublevel duplication for connectives such as through a previously proposed 'Imp'/'Implies' distinction.

RuleML files and messages strive for a strict separation of declarative content from procedural performatives, as pioneered by KQML. FOL RuleML is focused on the syntax and semantics of the FOL content language, specifying the FOL content formulas that can go into any performative of any other system that refers to the FOL RuleML namespace: these FOL formulas acquire their pragmatics from the enclosing performative context. Just for transmitting FOL RuleML content under a single XML root, without specifying what should be done with the content, we introduce a neutral performative, called 'Consider'. Appendix 1 gives a complete example, which uses the Horn subset of FOL to demonstrate a minimal XML wrapping of FOL RuleML content into performatives. Using FOL RuleML we may have, e.g., the same 'And' of clauses as the content that can be wrapped by, e.g., a KQML-'tell'-like 'Assert' performative. Appendix 2 gives an example of an 'Assert'-'And' nesting, which corresponds to a 'Rulebase' in RuleML 0.87. Since FOL RuleML permits implications as queries, the same content could moreover be wrapped by a 'Query' performative. Appendix 3 gives an FOL query example.

In this paper the performatives 'Consider', 'Assert', and 'Query' are the only examples used as wrappers (shown as blue-colored boxes) around FOL RuleML content (shown as white-colored boxes). Future RuleML work may contemplate a further performative wrapping an FOL formula used as an integrity constraint, which could be called 'Sustain'. Also, a 'Retract' performative, similar to KQML's 'untell', wrapping an FOL formula to be deleted, is relevant to some RuleML sublanguages. Certain performatives such as 'Query' can appear directly as the root of an XML file or message (e.g., the explicit 'Query' in Appendix 2) or could be generated by processors (e.g., a top-down interpreter) from content such as an 'Implies' rule (e.g., extracting the query implicit in the body conjunction of the 'Implies' in Appendix 1) to form a new XML file or message. However, the latter option is outside the scope of the RuleML language specification.

Since the Semantic Web Services Initiative (SWSI) is working in areas related to performatives, and is planning to use FOL RuleML as an FOL content language, we envisage a close RuleML/SWSI collaboration in finishing the FOL RuleML content language and in defining RuleML/SWSI performatives. The second aspect of this collaboration goes much beyond FOL RuleML since performatives involve other RuleML sublanguages such as Object-Oriented RuleML (OO RuleML) and are close to efforts in Reaction RuleML (Reaction TG). Also, previous work on OWL-QL (DQL) will be relevant here. One issue to be solved is how to build on Web Services standards such as SOAP when enriching the 'content' argument of performatives by further sublements for the receiver, sender, in-reply-to, etc. (which can become slots in OO RuleML).

The RuleML/SWSI/DAWG collaboration will be simplified by the modularity stemming from the separation of FOL RuleML content and RuleML/SWSI/DAWG/... performatives. The Syntax and Semantics of FOL RuleML is normative only w.r.t. the (white-boxed) FOL content language.

In the Quantifier RuleML module, explicit ('Forall' and 'Exists') quantifiers are allowed on all levels of rulebase elements, in particular immediately above and anywhere within implication elements.

For example, the RuleML 'own' rule (where the 'Imp' element happens to contain no rule-label child) own person object buy person merchant object keep person object ]]> will be rewritten with an 'Implies' connective (whose 'closure' attribute will normally be generated from the 'innerclose' attribute of the parent connective, usually an 'And'):

own person object buy person merchant object keep person object ]]>
The appendices illustrate an abridged version of this rule in context with the 'closure' attribute lifted to an 'innerclose' attribute.

This can be expanded to an 'own' rule with an explicit quantifier (a 'Forall' quantifier) extracting all variables that occur free in the 'closure'-attributed 'Implies'-connective formula. The extracted variables are put under 'declare' roles, and the 'closure'-less 'Implies' is put under a 'formula' role, as follows:

person merchant object own person object buy person merchant object keep person object ]]>
We will use the convention for role skipping of RuleML 0.87, which allows us to omit the 'declare' and 'formula' roles, as follows (where 'Var' type tags as direct child elements of 'Forall' get their role tag reconstructed as 'declare', while any other type tag gets reconstructed as 'formula'):

person merchant object own person object buy person merchant object keep person object ]]>
This itself can be considered as the prenex normal form of an 'own' rule with an explicit outer 'Forall' and an explicit inner (body-side) 'Exists' quantifier:

person object own person object merchant buy person merchant object keep person object ]]>

The 'Var' declaration part of quantified formulas like the above also provides a natural place to introduce types/sorts for those variables (once) as called for by OO RuleML.

Because of the unorderedness of roles, here 'head' and 'body' roles, the last but first version is syntactically equivalent to the following:

person merchant object buy person merchant object keep person object own person object ]]>
The role skipping of RuleML 0.87 now allows us to omit the 'head' and 'body' roles, as suggested by the type tag 'Implies' (as opposed to a -- not currently existing -- type tag 'IsImpliedBy'):

person merchant object buy person merchant object keep person object own person object ]]>
While the above examples are just different ways of expressing a Horn rule using explicit quantifiers, the following example uses them for added FOL expressiveness. This new rule about claiming, both of whose 'Implies' elements contain a rule label, leaves the outer 'Forall' implicit and employs an explicit inner (body-side) 'Forall' over an embedded 'Implies':

claiming-through-disclaimers claim person object x disclaiming-of-other-persons unequal x person disclaim x object keep person object ]]>
In a similar way, the RuleML 'keep' fact (where the 'Fact' element contains a rule-label and a 'head' child) Mary-keeps-everything keep Mary object ]]> or, using the ('head') role reconstruction of RuleML 0.87, Mary-keeps-everything keep Mary object ]]> will be rewritten as a 'keep' 'Atom' (whose 'closure' attribute will normally be generated from the 'innerclose' attribute of the parent connective, usually an 'And'):

Mary-keeps-everything keep Mary object ]]>
The appendices illustrate a version of this fact in context with the 'closure' attribute lifted to an 'innerclose' attribute.

This can be expanded to a 'keep' atom with an explicit quantifier (a 'Forall' quantifier) binding the declared free variable of the atomic formula, as follows:

object Mary-keeps-everything keep Mary object ]]>

Disjunctions in the head of clauses and in all sublevel positions are allowed in the Disjunctive RuleML module.

For example, the RuleML 'own' rule

own person object buy person merchant object keep person object ]]>
can be changed into a disjunctive ('own'-or-'relinquish') rule as follows:

own person object relinquish person object buy person merchant object ]]>
In a similar manner, we permit a disjunctive fact that could be derived by the above rule and a suitable 'buy' fact:

own Mary XMLBible relinquish Mary XMLBible ]]>

Explicit ('Forall' and 'Exists') quantifiers can be combined with disjunctions in the head of clauses and in all sublevel positions.

For example, this is a disjunctive ('claim'-or-'relinquish') rule with an inner (body-side) explicit quantifier (a 'Forall') over an embedded 'Implies':

claiming-or-relinquishing-through-disclaimers claim person object relinquish person object x disclaiming-of-other-persons unequal x person disclaim x object ]]>

Besides reducing 'Equivalent' to a pair of conjoined converse 'Implies', we also allow to represent it directly, modeled on 'Implies', but with a symmetric 'torso' role that combines the asymmetric 'head' and 'body' roles.

Classical negation in FOL RuleML is introduced as a 'Neg' element. (This is strictly separated from other RuleML sublanguages where partial-logic extensions to 'Neg' are permitted, from further sublanguages introducing the as-failure 'Naf' element, and from sublanguages also allowing certain 'Naf'/'Neg' combinations.)

The tag 'Neg' may be renamed into 'Not', as detailed in the Issues List, item 9.

While the 'Atom' element was so far restricted to the constructorless FOL subset, it will now be extended for complex terms as also used in RuleML's Hornlog sublanguage. First, besides 'Ind' or 'Var' children, an 'Atom' can now contain 'Cterm' child elements. Similarly, a complex term or 'Cterm' is then defined to apply a constructor or 'Ctor' child element to 'Ind', 'Var', or (recursively) 'Cterm' child elements.

The FOL RuleML syntax defines the connectives co-recursively in the usual FOL manner so that arbitrary nestings are allowed.

The shortened form of the FOL RuleML content language (for simplicity also omitting the rlab role on atoms and connectives) is defined through the following normative DTD grammar, where the ENTITY declaration handles the markupless recursive non-terminal 'foformula':

]]>

Note that the attributes 'innerclose' and 'closure' are specified, respectively, for boolean ('And'/'Or'/'Neg') and clause ('Atom'/'Implies'/'Equivalent') elements with the keyword #IMPLIED, which makes them optional. Since the 'closure' attribute is the fundamental one (cf. Appendix 1, Document 1b), on which the 'innerclose' attribute is based (cf. Appendix 1, Document 1a), users can opt to employ 'closure' without employing 'innerclose', but not the other way round. The 'closure' attribute specifies a universal or existential closure over all variables that occur free in its clause element. The 'innerclose' attribute specifies correspondingly valued 'closure'/'innerclose' attributes for all 'closure'/'innerclose'-less clauses/booleans occurring directly in its boolean element. It tells applications to propagate the value v ("universal" or "existential") found in a innerclose=v of a boolean element to their direct subelements, inserting closure=v into any clause that does not already have a 'closure' attribute, and recursively inserting innerclose=v into any boolean that does not already have an 'innerclose' attribute. This also allows the explicit 'Forall'/'Exists' quantification over the variables in a boolean or clause element that does not use an 'innerclose' or 'closure' attribute, respectively.

The semantics of the FOL RuleML content language is exactly the one of classical FOL model theory.

The above DTD is available for validation tests at http://www.ruleml.org/fol/fol-monolith.dtd. For example, Richard Goerwitz' STG Validator succeeds with the content language conjunction of the appendices:

Text: ... content from Appendix 1, Document 1a ... ]]>
While 'And' is distinguished here (after 'DOCTYPE') as the document root, 'Or' and the other connectives can be designated as the root, too.

The neutral 'Consider' performative, as illustrated in Appendix 1, for transmitting FOL RuleML content under a single document root can be added to the above DTD via the following non-normative line:

]]>

The usual formula simplifications and transformations can be applied to these FOL RuleML formulas (e.g., leading to normal forms). For example, 'And' is often needed in the body and (e.g., for SWRL) in the head of clauses, but an 'And' (such as a conjunction of converse 'Implies' elements) is not required on a rulebase top-level that is itself an 'And' of child formulas. As another example, applying de Morgan, a top-level 'Or' of 'Implies' (and 'Equivalent') rules can be re-expressed via the classical negation of an 'And' of the classically negated rules.

The tag 'Neg' may be renamed into 'Not', as detailed in the Issues List, item 9.

N-ary relations with named/keyed arguments can be expressed in FOL RuleML with slots, following OO RuleML. The Abstract Syntax sample formula with a named n-ary relationship from Peter Patel-Schneider's Proposal for a SWRL Extension to First-Order Logic is: Here is its XML Syntax in Slotted FOL RuleML (with two XML attributes: 'type' for webized classes and 'wref' for webized individuals):

x Purchase buyer seller object x quantity 1 ]]>

SWRL FOL and FOL RuleML can be joined to SWRL FOL RuleML by either adding RuleML extensions such as n-ary relations to SWRL FOL or by adding SWRL extensions such as data-valued properties to FOL RuleML.

Peter Patel-Schneider's Proposal for a SWRL Extension to First-Order Logic can provide the direct model-theoretic semantics for the SWRL FOL subset of SWRL FOL RuleML.

Using FOL RuleML as described here, the example assertion in XML concrete syntax of Peter Patel-Schneider's above document becomes the following SWRL FOL RuleML example (where the 'owlx:name' value has been webized and 'owlx:Annotation' has been left unchanged):

Example Rule for Expository Purposes ]]> x1 x2 x3 x4 x1 x2 x2 x3 x2 x4 ]]> ]]>

Notice that with rulebases becoming 'And' assertions, each fact inside becoming an 'Atom' (in SWRL, an 'individualPropertyAtom' or a 'datatypePropertyAtom'), this example can be viewed either as an asserted formula whose connective is an 'And' or as a rulebase of three facts grouped together by an 'And' connective.

Generally, in both views, FOL RuleML and SWRL FOL RuleML only permit one 'Assert' root per file or message. (Other, clearly distinct, RuleML sublanguages, studied by the Reaction TG, also permit for incremental, even dynamic, 'Assert' performatives, as required, e.g., for production rules.)

The SWRL Built-ins, being designed in a declarative fashion and used through a specialized 'Atom' ('swrlx:builtinAtom'), can be easily extended to SWRL FOL RuleML.

This is a test query using the 'swrlb:greaterThanOrEqual' built-in for SWRL FOL RuleML (we omit namespace declarations):

Test Query for Expository Purposes ]]> x1 x2 x3 x4 x1 x3 x2 x4 x3 x4 ]]> ]]>

To obtain the Schema of RuleML 0.9 we will incorporate the FOL modules along with other ones into the correspondingly adapted current XML Schema. The monolith DTD grammar of Syntax and Semantics and the monolith XSD derived from it for the XML Concrete Syntax of SWRL FOL will guide the modular XSD specification.

This document was produced as part of the DARPA DAML Program in close collaboration with the RuleML Initiative. It has benefited from extensive discussion in the Joint US/EU ad hoc Agent Markup Language Committee, with contributions from Sandro Hawke and Pat Hayes being worthy of particular mention. It has also benefited from the input of the Semantic Web Services Initiative (SWSI). FOL RuleML has already been used by Jing Mei as a target language for a transformational implementation of the OWL Semantics.