Glossary of Reaction RuleML 1.02

From RuleML Wiki
Jump to: navigation, search

Authors: Adrian Paschke, Tara Athan, Harold Boley


Quick links:

RuleML Families : Specification of RuleML 1.02

Prerequisites: None, Level: Semi-formal

Reaction RuleML : Specification of Reaction RuleML

Prerequisites: None, Level: Semi-formal

Primer : Tutorial on RuleML

Prerequisites: None, Level: Informative

XSD Schemas : Machine-readable schemas in XSD

Prerequisites: XSD, Level: Formal

Examples : Illustrative Instances of the Version 1.02 Language

Prerequisites: Primer, Level: Informative

Glossary : Definitions of Elements and Attributes

Prerequisites: Primer, Level: Semi-formal

Content Models : Simplified XML Element and Attribute Definitions

Prerequisites: Primer, Level: Semi-formal

Schema Docs : Diagrammatic Presentation of Content Models

Prerequisites: Primer, Level: Semi-formal

Implementations : Implemented RuleML tools

Prerequisites: None, Level: Informative

This version: reaction.ruleml.org/1.02/glossary

Latest version: reaction.ruleml.org/glossary

This glossary describes every element, attribute and (new in version 1.02) syntactic category of Reaction RuleML as of version 1.02. The typographic convention is <Element> for the names of XML elements, @attribute for XML attributes, and Syntactic Category for non-terminal syntactic categories.

Contents

1 <Action>

Explicit generic Action Node that is a function, relation, compound term or simple formula. An action can be defined

The optional @type attribute defines the type of the action, the optional @safety attribute indicates if this is an interrupting, non-interrupting, transactional action, and the optional @card @minCard @maxCard attribute acts as a generic size counter for the number of actions to be executed in a complex action.

Like [#gloss-Uniterm Uniterm]s the interpretation of an Action as object, relation, (complex) term, function with or without side effects and its model-theoretic truth interpretation, is context sensitive on where it is used and depends on the reasoning/execution @style of the Reaction RuleML dialect and the intended semantic interpretation/evaluation <Profile>.

See schema docs.

2 <after>

The "after" Edge of a rule <Rule> defining a post-condition after the action execution (<do>), e.g. to define a post-conditional integrity test which rolls back transactional actions (@safety) or triggers a compensating action in the <elseDo> part.
See schema docs.

3 <After>

An algebra Operation sentence defining a time (<Time>) or spatial (<Spatial>) which follows after another time or spatial, i.e. "X after Y". "Y" might be absolute or relative, e.g. "after 2 days" (relative), "2 days after X" (absolute).
See schema docs.

4 <Agent>

A generic Metalogical Node Agent element used to describe agents (e.g. event processing agent, analytic agent, agent-based rule inference service, reactive agents). An agent can be defined by arbitrary XML syntax (e.g. an existing XML-based Agent/Service language) within its <content> role tags and by references to an external definition (e.g. a Web Ontology resource) using the @type (agent type) and @iri (agent instance / address) attribute. Agent definitions can be used in messaging reaction rules within the sender (<sender>) and receiver (<receiver>) role tags in a message (<Message>).
See schema docs.

5 <And>

Connective sentence resulting from the application of a variably polyadic conjunction connective to zero or more formulas (called the conjuncts).
See schema docs.

6 <Answer>

A performative wrapper giving the answers to a query (<Query>) or results from a forward directed rule processing/reasoning as in the case of production rules and reaction rules with actions. Used e.g. in Question-Answering (Q&A - see Rule Responder project) communication with messages (<Message>) or in testing (<Test>). For instance, for a query "<Query><Rel>p</Rel><Var>x</Var><Var>y</Var><Var>z</Var></Query>" the answer is given in terms of solved formulas, e.g. as a rulebase (<Rulebase>) that contains 'solved' equations with the variable bindings.
<Rulebase>
   <Equal><Var>x</Var><Ind>a</Ind></Equal>
   <Equal><Var>y</Var><Ind>b</Ind></Equal>
   <Equal><Var>z</Var><Ind>c</Ind></Equal>
 </Rulebase>

or as ground literals (<Atom>) matching the query / goal

<Atom>
   <Rel>p</Rel>
   <Ind>a</Ind>
   <Ind>b</Ind>
   <Ind>c</Ind>
</Atom>

or as entailment (<Entails>) of the answer from the instantiated rule base.

With the optional <degree> edge a truth/uncertainty value (between 0.0 and 1.0; with the truth values "1" for true and "0" for false in two-valued logics and "0.5" for unknown in three-valued logics) can be assigned to the answer. An answer maybe be also just referenced by the local key-keyref mechanism (@key-@keyref) or by the optional @iri attribute, in case of externally published answers (as e.g. in decoupled interaction as in event streaming). With the optional @type attribute an answer type can be specified. The @safety optionally defines if the answer (event) is interrupting or non-interrupting and the @card @minCard @maxCard attribute optionally defines the number of results contained in an Answer.

See schema docs.

7 <Any>

An event algebra Operation sentence defining an any operation for events (<Event>, <Sequence>, <Disjunction>, <Xor>, <Conjunction>, <Concurrent>, <Not>, <Any>, <Aperiodic>, <Periodic>, <AtMost>, <AtLeast>, <Operation>).

Or a temporal or spatio algebra Operation sentence defining a time (<Time>) or spatial (<Spatial>) which repeats any list of [time or spatial], i.e. "any X1,..Xn", e.g. "any Saturday and Sunday".

See schema docs.

8 <Aperiodic>

An event algebra Operation sentence defining an aperiodic operation ("Event2 does occur aperiodically between [Event 1 and Event3]") for the aperiodic occurrence of an event (<Event>, <Sequence>, <Disjunction>, <Xor>, <Conjunction>, <Concurrent>, <Not>, <Any>, <Aperiodic>, <Periodic>, <AtMost>, <AtLeast>, <Operation>) within an interval of two other events.
See schema docs.

9 <arg>

Edge containing a term child, used for the positional arguments of a logical atom (<Atom>), functional expression (<Expr>)
See schema docs.

10 @arity

Defines the arity in a signature definition.

See schema docs.

11 <Assert>

Performative specifying that its content (optionally surrounded by <formula> role tags) is asserted, making an 'implicit <Rulebase>' assumption. This allows the separation of declarative content from such procedural performatives (as pioneered by KQML, which has a similar performative 'tell')[1].
See schema docs.

12 <at>

Edge used in event algebra operators and in reified calculi for event/action/situation reasoning containing times (explicit <Time> or <Interval>, as e.g. in event calculus and temporal situation calculus, or a branching history of <Situation>s, as e.g., in classical situation calculus, or event/action intervals, as in interval-based event logics)
See schema docs.

13 <AtLeast>

An event algebra Operation sentence defining an atleast operation ("AtLeast @card @minCard @maxCard occurrences on Event") counting the minimum number of events (<Event>, <Sequence>, <Disjunction>, <Xor>, <Conjunction>, <Concurrent>, <Not>, <Any>, <Aperiodic>, <Periodic>, <AtMost>, <AtLeast>, <Operation>). The @card @minCard @maxCard attribute defines the number of event occurrences which at least are allowed to occur.
See schema docs.

14 <AtMost>

An event algebra Operation sentence defining an atmost operation ("AtMost @card @minCard @maxCard occurrences on Event") counting the maximum number of events (<Event>, <Sequence>, <Disjunction>, <Xor>, <Conjunction>, <Concurrent>, <Not>, <Any>, <Aperiodic>, <Periodic>, <AtMost>, <AtLeast>, <Operation>). The @card @minCard @maxCard attribute defines the number of event occurrences which at most are allowed to occur.
See schema docs.

15 <Atom>

Simple formula that is a logical atom, i.e. an expression formed from a predicate (or relation) applied to a collection of operands. The relation (<Rel>) is followed by a sequence of zero or more positional arguments (<arg>). Optional slots (<slot>) are also permitted. Rest variables -- <repo> (positional) and <resl> (slotted) -- are also permitted. For example, one way to formalize "John is the father of a daughter, Mary and a son, Bill":
 <Atom>
   <Rel>is father of</Rel>
   <Ind>John</Ind>
   <slot><Ind>daughter</Ind><Ind>Mary</Ind></slot>
   <slot><Ind>son</Ind><Ind>Bill</Ind></slot>
 </Atom>
See schema docs.

16 Attribute

Construct determined by a property and a value, where the value is a piece of data.
  • A RuleML/XML attribute is an unqualified XML attribute manifestation of an (abstract) RuleML attribute, defined by the RuleML schemas, where the property is indicated by the XML attribute name and the value is indicated by the XML attribute value. There are no qualified XML attributes defined in the RuleML namespace.
See @card @closure @direction @index @iri @key @keyref @mapClosure @mapDirection @mapMaterial @material @maxCard @minCard @mode @node @oriented @per @prefix @safety @style @type @val @vocab @weight

17 <Before>

An algebra Operation sentence defining a time (<Time>) or spatial (<Spatial>) which is before another time or spatial, i.e. "X before Y". "Y" might be absolute or relative, e.g. "2 days before" (relative), "2 days before X" (absolute).
See schema docs.

18 Branch Node

Node which can contain another Node, i.e., all Nodes that are not Leaf Nodes.

19 @card

Semantic variant Attribute optionally specifying a <slot>'s cardinality.
See schema docs.

20 <Choice>

An action algebra Operation sentence defining a non-deterministic choice operation on a set of actions (<Action>, <Assert>, <Retract>, <Update>, <Query>, <Operation>, <Succession>, <Choice>, <Flow>, <Loop>).
See schema docs.

21 <cid>

A conversation identifier Edge used to identify a conversation in which a <Message> is interchanged.
See schema docs.

22 @closure

Attribute indicating how the contained free variables are quantified. Predefined values are "universal" and "existential", while arbitrary quantification operators (e.g. numerical quantification, such as unique existential quantification - there is one and only one) can be referenced as IRIs.
See schema docs.

23 Compound Formula

Formula that may contain other formulas.
Subcategories: Connective Sentence, Quantified Sentence

24 Compound Term

Term that may contain other terms.
See: <Expr> <Plex> <Uniterm>

25 <Concurrent>

An event algebra Operation sentence defining a concurrent operation for concurrent events (<Event>, <Sequence>, <Disjunction>, <Xor>, <Conjunction>, <Concurrent>, <Not>, <Any>, <Aperiodic>, <Periodic>, <AtMost>, <AtLeast>, <Operation>).
See schema docs.

26 <Conjunction>

An event algebra Operation sentence defining a conjunction operation for an unordered conjunction ("event 1 and event 2") of events (<Event>, <Sequence>, <Disjunction>, <Xor>, <Conjunction>, <Concurrent>, <Not>, <Any>, <Aperiodic>, <Periodic>, <AtMost>, <AtLeast>, <Operation>).
See schema docs.

27 Connective Sentence

Compound formula resulting from the application of a logical connective to zero or more formulas.
See: <And> <Equivalent> <Implies> <Neg> <Or>

28 <Const>

Simple term for a function, relation, or individual represented as a neutralized constant.
See holog RNC module

29 Construct

Syntactic entity, either abstract or concrete.
  • A RuleML/XML construct is an XML element or attribute defined by the RuleML schemas.
Subcategories Node, Edge, Attribute, Slot

30 <Consult>

A performative action wrapper that dynamically "consults" (imports) the knowledge from an enclosed (<enclosing>) message (<Message>) or an external knowledge source (referenced by the @iri attribute), e.g. <Consult iri="http://reaction.ruleml.org/1.02/exa/dr/DistributedDerivationRuleInterface.rrml"/>.
See schema docs.

31 <content>

Edge used for as extensible content argument, which acts as an syntactic extension point to embed xs:any XML code in the argument. It can be used to extend the content of <Time>, <Spatial>, <Interval>, <Action>, <Event>, <Situation>, <Profile>, <Message>, <Agent>, <Protocol>. The optional @vocab and @prefix can be used to define vocabulary and prefix mappings to be used for the translation of terms and Curies to absolute IRIs in the <content>.
See schema docs.

32 <Data>

Simple term indicating a fixed character sequence (like XML PCDATA and RDF literals). It may be optionally associated with an XML Schema built-in datatype using the xsi:type attribute. For example:
<Data xsi:type="xs:dateTime">2002-10-10T17:00:00Z</Data>
is valid (according to the dateTime datatype), but the following is not:
<Data xsi:type="xs:dateTime">tomorrow</Data>
Note, however, that <Data>tomorrow</Data> is valid because no built-in datatype is given and that XML is also permissible, e.g.
<Data>
  <ex:object>
   <ex:id>115897</ex:id>
   <ex:owner>John Doe</ex:owner>
  </ex:object>
</Data>
See schema docs.

33 <declare>

Edge used for variables (<Var>) declared within a quantifier (<Forall> or <Exists>).
See schema docs.

34 <degree>

Edge containing a data value indicating an uncertainty value (between 0.0 and 1.0 or qualitatively expressed) of a formula.[2]
See schema docs.

35 @direction

Semantic variant Attribute indicating the intended direction of an implication rule's (<Implies>) inferencing. Predefined values are "bidirectional", "forward", and "backward". If the syntactic scope of the semantic profile allows the @direction to be absent, then the semantic profile should specify to which value this corresponds (see Semantic Variant Attributes).
See schema docs.

36 <directive>

Edge for specifying the pragmatic characterization of a message (<Message>) context, broadly characterizing the meaning of a message in a communicative situation / interaction by referencing (external) vocabularies / ontologies, e.g. the speech act theory-based communicative acts from the FIPA Agent Communication Language, or the KQML inspired RuleML primitives, or alethic and deontic logic modal operator etc.
See schema docs.

37 <Disjunction>

An event algebra Operation sentence defining a disjunction operation for a disjunction ("event 1 or event 2") of events (<Event>, <Sequence>, <Disjunction>, <Xor>, <Conjunction>, <Concurrent>, <Not>, <Any>, <Aperiodic>, <Periodic>, <AtMost>, <AtLeast>, <Operation>).
See schema docs.

38 <do>

Edge containing a performative / action (e.g. <Assert>, <Query>, <Retract>, <Consult>, <Answer>, <Update>, <Test>, <Send>, <Receive>).
See schema docs.

39 <Do>

a function used in reified calculi for for event/action/situation/fluent reasoning (e.g. event calculus, situation calculus, fluent calculus, etc.) that takes a (reified) action ( <Action>) and transfers a give situation into a new situation which includes the action (i.e. Do: A x S -> S).
See schema docs.

40 <During>

An interval algebra Operation sentence defining a relation between two intervals (<Interval>), here "X during Y".
See schema docs.

41 Edge

Construct determined by a role and a Node construct that is a role filler.
Disjoint from Node, Attribute, and Slot
  • A RuleML/XML edge element is an XML element manifestation of an (abstract) RuleML edge, consisting of a role tag pair (<role>, </role>), optionally with attributes, that indicates the role, and the Node element content that indicates the role filler.
See

<after> <arg> <at> <cid> <content> <declare> <degree> <directive> <do> <else> <elseDo> <enclosed> <evaluation> <expectedResult> <fluent> <formula> <guard> <if> <left> <meta> <oid> <op> <payload> <protocol> <qualification> <quantification> <receiver> <repo> <resl> <right> <scope> <sender> <signature> <strong> <then> <torso> <vvi> <weak>

42 <else>

Edge containing a logical else conclusion in a <Rule>. An if-then-else rule is syntactic sugar for to two rules where the first rule is the normal if-then derivation rule and the second rule has the negation of the premise of the first rule and the else as conclusion.
See schema docs.

43 <elseDo>

Edge containing an else action in a <Rule>. The alternative action will be executed if the "normal" rule execution fails. The default semantics applies the elseDo to the negation of the <if>-part in production rules and the negation of the combined <if>-<do>-<after>-part ("if ∧ do ∧ after") in ECA/CEP reaction rules, i.e. if one of the parts fails the alterantive elseDo action is executed (e.g. to roll-back or compensate action effects). A deviating semantics for a <Rule> with elseDo can be specified in the semantic <Profile> of the rule.
See schema docs.

44 <enclosed>

Edge enclosing a RuleML message (<Message>) in messaging actions/primitives (<Consult> <Send> <Receive>).
See schema docs.

45 <Entails>

Metalogical Node used to <Assert>/<Query> that/whether the antecedent (<if> child) entails the formulas in the consequent (<then> child), e.g. the first acting as a knowledge base and the second acting as its integrity constraints.
See schema docs.

46 <Equal>

Simple formula for an equation containing a left and a right term, each of which may be optionally surrounded by left (<left>) or right (<right>) role tags, resp. For example, "factorial(0)=1" may be equivalently represented in the following two ways:
Compact serialization
<Equal>
  <Expr>
    <Fun>factorial</Fun>
    <Data xsi:type="xs:int">0</Data>
  </Expr>
  <Data xsi:type="xs:int">1</Data>
</Equal>
Normalized serialization
<Equal>
  <left>
    <Expr>
      <Fun>factorial</Fun>
      <Data xsi:type="xs:int">0</Data>
    </Expr>
  </left>
  <right>
    <Data xsi:type="xs:int">1</Data>
  <right>
</Equal>
See schema docs.

47 <Equivalent>

Connective sentence resulting from the application of a binary logical connective of equivalence, which is "syntactic sugar" for a pair of conjoined converse implication rules (<Implies>). It contains a pair of formulas (optionally surrounded by <torso> role tags). For example, "A person owning an object is equivalent to an object belonging to a person":
<Equivalent>
  <torso>
    <Atom>
      <Rel>own</Rel>
      <Var>person</Var>
      <Var>object</Var>
    </Atom>
  </torso>
  <torso>
    <Atom>
      <Rel>belongs</Rel>
      <Var>object</Var>
      <Var>person</Var>
    </Atom>
  </torso>
</Equivalent>
See schema docs.

48 <evaluation>

An optional Edge used to define the intended semantics (e.g. model theoretic semantic, proof-semantics, operational semantics such as selection and consumption policies etc.) in terms of a Semantic <Profile>. Multiple alternative semantics can be defined by repeating the evaluation role and a prioritization ordering can be imposed by using the @index attribute.
See schema docs.

49 <Event>

Explicit generic Event Node. An event can be defined

There is a distinction into the event interface/definition/pattern/signature which is define by the <signature> and the concrete implementation/instantiation of an event object. It is possible to define the interface signature of an event separated from its implementation by using the @key @keyref attributes.

The optional @type attribute defines the type of the event, the optional @safety attribute indicates if this is an interrupting, non-interrupting, transactional event, and the optional @card @minCard @maxCard attribute acts as a generic size counter for the number of events in a complex event.

Like Uniterms the interpretation of an Event as object, relation, (complex) term, function with or without effect and its model-theoretic truth interpretation, is context sensitive on where it is used in a formula and depends on the reasoning/execution @style of the Reaction RuleML dialect and the intended semantic interpretation/execution <Profile>.

See schema docs.

50 <Every>

An algebra Operation sentence defining a time (<Time>) or spatial (<Spatial>) which repeats every time or spatial, i.e. "every X", e.g. "every Monday", "every 2 meters".
See schema docs.

51 <Exists>

Quantified sentence resulting from the application of an existential quantifier. It contains one or more bound variables (<Var>), each optionally surrounded by <declare> role tags, and a logical formula (optionally surrounded by <formula> role tags).
See schema docs.

52 <expectedResult>

Edge used to define the expected result as a predefined (<Answer>) in a test item (<TestItem>).
See schema docs.

53 <Expr>

Compound term that is a functional term of the form "f(...)" where f is a function name. The function name (<Fun>) is followed by a sequence of zero or more arguments (<arg>). Optional user-defined slots (<slot>) are also permitted, just like an atom (<Atom>). Rest variables for positional arguments (<repo>) and slot arguments ( <resl>) are also permitted.
See schema docs.

54 <Finishes>

An interval algebra Operation sentence defining a relation between two intervals (<Interval>), here "X finishes Y".
See schema docs.

55 <Flow>

An action algebra Operation sentence defining a parallel (execution) flow of actions (<Action>, <Assert>, <Retract>, <Update>, <Query>, <Operation>, <Succession>, <Choice>, <Flow>, <Loop>).
See schema docs.

56 <fluent>

Edge used in reified calculi for <Fluent>s (changeable Situation properties which are initiated (<Initiates>) or terminated (<Terminates>) by events/actions (<Event>/<Action>) and which hold (<Holds>) at (<at>) a time or in a situation (explicit time/intervals <Time>/<Interval> or <Situation> histories) in event/action/situation reasoning such as event calculus, situation calculus, fluent calculus, etc.
See schema docs.

57 <Fluent>

a <Fluent> Node is changeable Situation property which is initiated (<Initiates>) or terminated (<Terminates>) by events/actions (<Event>/<Action>) and which holds (<Holds>) at (<at>) a time or in a situation (explicit time/intervals <Time>/<Interval> or <Situation> histories). It is possibly surrounded by <fluent> role tags. It is used in event/action/situation reasoning such as event calculus, situation calculus, fluent calculus, etc. to represent and reason about the effects of event/actions on changeable properties (fluents) within a conditional situation context.
See schema docs.

58 <Forall>

Quantified sentence that is an explicit universal quantifier. It consists of one or more variables (<Var>), each optionally surrounded by <declare> role tags, followed by a logical formula (optionally surrounded by <formula> role tags).
See schema docs.

59 <formula>

Edge for the formula(s) of a conjunctive (<And>) or disjunctive (<Or>) formula, quantifier (<Forall> or <Exists>), rulebase <Rulebase>), or performative (<Assert>, <Query> or <Retract>).
See schema docs.

60 Formula

Node indicating a member of a theory or rulebase. It is complementary to the syntactic category of terms.
Subcategories: Simple Formula, Compound Formula

61 <Fun>

User-defined function in an <Expr>. It is optionally surrounded by operator (<op> role tags).
See schema docs.

62 Function

Node indicating the mapping that is applied in an expression (functional term).
See <Fun>, <Const>, <Var>, <Uniterm>, <Expr>, <Skolem>, <Reify>, <Data>, <Ind>

63 <guard>

An optional Edge used to define guards acting as pre-constraints which are validated before the conditions/goals, events and actions of a <Rule> or <Query>. Guards can be used as quantifier guards (in the formula role of <Quantifier>, <Forall>, <Exists>), as pre-constraints for goals in the <if> conditions, e.g. to validate general integrity constraints, as pre-conditions for events and actions, and for meta reasoning within knowledge base scopes (see <scope>) which are constructively defined over descriptive and qualifying metadata (<meta> and <qualification>).
See schema docs.

64 <Happens>

a generic Simple Formula used in reified calculi for event/action/situation/fluent reasoning (e.g. event calculus, situation calculus, fluent calculus, etc.). The Happens predicate defines a predicate relation between events/actions (<Event> / <Action> possibly surrounded by <on> role tags) and times (explicit <Time> possibly surrounded by <at> role tags, as e.g. in event calculus and temporal situation calculus, or a history of <Situation>s, as e.g., in classical situation calculus). Different sorts happens predicates / happenings can be defined by reference to an external vocabulary with the @iri attribute, e.g. a vocabulary for a calculi which distinguishes between events which actually happen and other event relations over time or situations such as "poss", "planned", etc.
See schema docs.

65 <Holds>

a generic Simple Formula used querying <Fluent>s in reified calculi for event/action/situation/fluent reasoning (e.g. event calculus, situation calculus, fluent calculus, etc.). The Holds predicate defines a predicate relation between fluents (<Fluent>) and times (explicit <Time>, as e.g. in event calculus and temporal situation calculus, or a history of <Situation>s, as e.g., in classical situation calculus). Different sorts of the holds predicates can be defined by reference to an external vocabulary with the @iri attribute.
See schema docs.

66 <if>

Edge for the "if" part of an implication rule (<Implies>) containing the premise(s), also known as the "antecedent" or "body" of the rule. Also used as the "antecedent" part of an entailment (<Entails>).
See schema docs.

67 <Implies>

Connective sentence that is an implication rule. It consists of a conclusion role (<then>) followed by a premise role (<if>), or, equivalently (since roles constitute unordered elements), a premise role followed by a conclusion role. For example, "The discount for a customer buying a product is 5.0 percent if the customer is premium and the product is regular":
<Implies>
  <if>
    <And>
      <Atom>
        <Rel>premium</Rel>
        <Var>customer</Var>
      </Atom>
      <Atom>
        <Rel>regular</Rel>
        <Var>product</Var>
      </Atom>
    </And>
  </if>
  <then>
    <Atom>
      <Rel>discount</Rel>
      <Var>customer</Var>
      <Var>product</Var>
      <Ind>5.0 percent</Ind>
    </Atom>
  </then>
</Implies>
Alternatively, the roles may be skipped, in which case the premise comes first followed by the conclusion as suggested by the element name 'Implies' (since the if of a rule implies the 'then', not vice versa). Using the same example, the order changes:
<Implies>
  <And>
    <Atom>
      <Rel>premium</Rel>
      <Var>customer</Var>
    </Atom>
    <Atom>
      <Rel>regular</Rel>
      <Var>product</Var>
    </Atom>
  </And>
  <Atom>
    <Rel>discount</Rel>
    <Var>customer</Var>
    <Var>product</Var>
    <Ind>5.0 percent</Ind>
  </Atom>
</Implies>
See schema docs.

68 <Ind>

Simple term that is an individual constant, as in predicate logic (which can have an IRI like an RDF resource).
See schema docs.

69 @index

Attribute required for specifying the position of a positional argument (see <arg>) within a logical atom (<Atom>). Also used to specify the position of a performative (see <do>) within the top element (<RuleML>), and optionally the position of a formula (see <formula>) within ordered Conjunction (<And>) and Disjunction (<Or>).
See schema docs.

70 <Initiates>

a generic Simple Formula used in reified calculi for event/action/situation/fluent reasoning (e.g. event calculus, situation calculus, fluent calculus, etc.). The Initiates predicate defines when a fluents (<Fluent>) is initiated by an event/action(<Event>, <Action>) at a time (explicit <Time>, as e.g. in event calculus and temporal situation calculus, or a history of <Situation>s, as e.g., in classical situation calculus). Different sorts of the initiates predicates can be defined by reference to an external vocabulary with the @iri attribute.
See schema docs.

71 <Interval>

Explicit generic Interval Node. Within the <arg> role (possibly omitted) an interval can be defined for events, actions, situations, times, spatials and other intervals. Within the <content> role (possibly omitted) an interval can be defined for any XML content (xs:any). The optional @type is used to define the sort of interval (predefined sorts in the RuleML Metamodel are: "EmptyInterval", "DegeneratedInterval", "LeftClosedRightOpenInterval", "LeftOpenRightClosedInterval, "LeftOpenInterval, "LeftClosedInterval, "RightClosedInterval", "RightOpenInterval"). The optional @iri attribute can be used to point to an external definition of the interval. Interval algebra operators (<During>, <Overlaps>, <Starts>, <Precedes>, <Succeeds>, <Meets>, <Equal>, <Finishes>, <Operation>) are used to relate intervals.
See schema docs.

72 @iri

Attribute optionally on <Ind>, <Rel>, and <Fun> for referring to an IRI like for XHTML anchors. On <Ind>s (or <Const>s, in frame sublanguages) within an <oid>, this attribute can also act as a web label.
See schema docs.

73 @key

Attribute optionally on Nodes, serving as a label for distributed syntax.
See schema docs.

74 @keyref

Attribute optionally on Nodes, serving as a reference to a @key label for distributed syntax.
See schema docs.

75 Leaf Node

Node which may not contain another Node.
See Simple Term, <Rel>, <Fun>

76 <left>

Edge for the left-hand side of an equation (<Equal>).
See schema docs.

77 <Loop>

An action algebra Operation sentence defining a loop operation for an action (<Action>, <Assert>, <Retract>, <Update>, <Query>, <Operation>, <Succession>, <Choice>, <Flow>, <Loop>). The optional @card @minCard @maxCard attributes can be used to define the maximum number of loops.
See schema docs.

78 @mapClosure

Attribute indicating how the free variables falling within its scope (i.e. child elements) are quantified. See attribute mapping for more details. Predefined values are "universal" and "existential".
See schema docs.

79 @mapDirection

Semantic variant Attribute indicating the intended direction of implication rule (<Implies>) inferencing of elements falling within its scope (i.e. child elements). See attribute mapping for more details. This attribute has a neutral value of "bidirectional". Other allowed values are "forward" and "backward".
See schema docs.

80 @mapMaterial

Semantic variant Attribute indicating the kind of all implication rules (<Implies>) falling within its scope (i.e. child elements). See attribute mapping for more details. Predefined values are "yes" and "no".
See schema docs.

81 @material

Semantic variant Attribute indicating the kind of an implication rule (<Implies>). Predefined values are "yes" and "no".
See schema docs.

82 @maxCard

Attribute optionally specifying a <slot>'s maximum cardinality.
See schema docs.

83 <Meets>

An interval algebra Operation sentence defining a relation between two intervals (<Interval>), here "X meets Y".
See schema docs.

84 <Message>

A Message Node that provides the syntax for inbound and outbound messages / notifications. A message consists of
  • an <cid> which is the conversation identifier (enabling also long-running asynchronous conversations and sub-conversations with new conversation identifiers),
  • an optional <protocol>: protocol definition (e.g. high-level negotiation and coordination protocols, agent protocols and operational transport protocols)
  • an optional <sender> and <receiver> : indicates the sender and the target of the message,
  • a <directive>: pragmatic context defining the pragmatic interaction and interpretation context for the message payload, e.g. FIPA Agent Communication Language primitives such as "acl:query-ref",
  • an optional @type defines the type of the message and an optional @mode attribute distinguishes "inbound" from "outbound" communication,
  • a <payload> transporting any valid <RuleML> knowledge (enclosing queries (<Query>), answers (<Answer>), includes, imports and updates (<Consult>, <Assert>, <Retract>, <Update>) and and general actions (<Action>)) or arbitrary XML <content> (note: the <payload> role might be omitted if a reference to some external message source is provided, either by using the @keyref attribute to a local knowledge or to an external source using the @iri attribute.

Messages are used in CEP Reaction RuleML for inter-operation and (platform-independent) interchange of rule-bases, events, actions, queries and answers between distributed rule-based agents/inference services (e.g. event processing agents, decision support agents etc.) which interact with each other using messaging reaction rules with <Send> and <Receive> actions (see Prova project for an implementation of messaging reaction rules). In such agent/service interactions (Reaction) RuleML is used as common standardized rule interchange format (see RuleResponder project and RuleResponder article) between possibly different platform-specific rule engines (such as Prova, OO jDrew, Drools, Emerald). To safeguard semantic interoperation semantic profiles (<Profile>) and test cases (<Test>) for validation and integrity testing can be explicitly interchanged together with the rules, queries and actions/events (see Reaction RuleML 1.0 Perspective on Standards).

See schema docs.

85 <meta>

Edge for an optional role for internally attaching to a Node a single formula as meta-knowledge. Not available for leaf Nodes, such as <Var> or <Rel>.
See schema docs.

86 @meta

Attribute referencing <meta> annotations.
See schema docs.


87 Metalogical Node

Node indicating a metalogical formula or term
See Entails Rulebase

88 @minCard

Attribute optionally specifying a <slot>'s minimum cardinality.
See schema docs.

89 @mode

Attribute optionally specifying the intended input-output constellations of the predicate terms with the following semantics:
  • "+" The term is intended to be input
  • "-" The term mode is intended to be output
  • "?" The term is undefined (input or output)

The default is ?

In CEP Reaction RuleML the mode attribute is also used in <Message> for defining the communication mode with the values "inbound", "outbound" and "bidirectional" communication.

See schema docs.

90 <Naf>

Compound formula for a "by default" negation of a logical atom (<Atom>) (i.e. "weak" negation or negation as failure). The negated atom may be optionally surrounded by <weak> role tags.
See schema docs.

91 <Neg>

Connective sentence that is a classical negation of a logical atom (<Atom>) (i.e. classical or "strong" negation). The negated atom may be optionally surrounded by <strong> role tags.
See schema docs.

92 <Negation>

Connective sentence taht is a generic negation of an atomic formula (with the <formula> role possibly omitted). It either acts as a polymorphic negation which is interpreted according to the intended semantics (defined e.g. by the semantic <Profile>) or the sort is explicitly defined by the optional @type attribute, e.g. using predefined negation types from the RuleML Metamodel. For instance, <Naf> is a shortcut for a generic negation <Negation type="ruleml:InflationaryNegation"> (in PR Reaction RuleML) or <Negation type="ruleml:DefaultNegation"> (in DR/KR Reaction RuleML) and <Neg> for <Negation type="ruleml:StrongNegation">.
See schema docs.

93 Node

Construct determined by a type and a description, as a collection of constructs, of a member of that type.
  • A RuleML/XML Node element is an XML element manifestation of an (abstract) RuleML Node, consisting of a type tag pair (<type>, </type>) that indicates the type, and attributes together with the element content that indicate the description.
Disjoint from Edge, Attribute, and Slot
Subcategories Branch Node, Leaf Node, Formula, Term, Relation, Function, Metalogical Node, <Uniterm>

94 @node

Attribute for an optional IRI identifier for a Node, creating accessibility within the knowledge representation. This can help for representing prioritization between rules, for example. All Node tags (i.e. those that begin with an Uppercase letter) of RuleML can be decorated with such an identifier.
See schema docs.

95 <Not>

An event algebra Operation sentence defining a not operation ("Event 2 does not occur between [Event 1 and Event 3]") which defines that an event (<Event>, <Sequence>, <Disjunction>, <Xor>, <Conjunction>, <Concurrent>, <Not>, <Any>, <Aperiodic>, <Periodic>, <AtMost>, <AtLeast>, <Operation>) must not occur within an interval of two other events .
See schema docs.

96 <oid>

Edge for an optional label for the object of a slotted atom or expression.
See schema docs.

97 <on>

Edge for the "on" part of a reaction rule (<Rule>). Also called the "event" part.
See schema docs.

98 <op>

Edge for a role for operators of atoms (<Atom>), functional expressions (<Expr>), or, in Holog languages, uniterms (<Uniterm>). In expressivities up to FOL, this edge contains either a relation (<Rel>) or a function name (<Fun>). In Holog languages, it may also contain a neutralized constant (<Const>).
See schema docs.

99 <Operation>

An extensible, generic Operation sentence for e.g. user-defined logical connectives, modal operators, algebra operators. The sort of an operations can be defined by an external ontology using the @type attribute and externally defined operations can be referenced by the @iri attribute.
See schema docs.

100 <Or>

Connective sentence resulting from the application of a variably polyadic disjunction connective to zero or more formulas (called the disjuncts).
See schema docs.

101 Operation Sentence

Operator used to connect two or more sentences. This includes logical operators such as logical connective, modal operators, algebra operators.

102 @oriented

Semantic variant Attribute indicating whether an equation (<Equal>) is oriented (directed) or unoriented (symmetric). Predefined values are "no" (unoriented) and "yes" (oriented). For example, the (oriented) defining equation home(father-of(John)) = Mexico City appears as follows:
<Equal oriented="yes">
  <left>
    <Expr>
      <Fun per="value">home</Fun>
      <Expr>
        <Fun per="copy">father-of</Fun>
        <Ind>John</Ind>
      </Expr>
    </Expr>
  </left>
  <right>
    <Ind>Mexico City</Ind>
  </right>
</Equal>
See schema docs.

103 <Overlaps>

An interval algebra Operation sentence defining a relation between two intervals (<Interval>), here "X overlaps with Y".
See schema docs.

104 <payload>

An optional Edge in RuleML messages (<Message>) to specify the payload as a <RuleML> knowledge base.
See schema docs.

105 @per

Semantic variant Attribute indicating whether a simple function name (<Fun>) or an expression used as a complex function name (<Expr>) will be interpreted.[3] In equality sublanguages, it has three values "copy", "value", and "open", while in non-equality sublanguages it can only have the value "copy".
See schema docs.

106 Performative

Construct used to represent side-effectful operations on a knowledge base
See: <Assert> <Retract> <Query>

107 <Periodic>

An event algebra Operation sentence defining a periodic operation ("at Time2 between event time interval [Event 1 and Event3]") of a time (a time event) which occurs at an interval (<Interval>).
See schema docs.

108 <Plex>

Compound term that contains a collection of (ordered) arguments (optionally enclosed by <arg>) and/or (unordered) user-defined slots (<slot>), analogous to an expression (<Expr>) with the uninterpreted (constructor) function (equivalent to having a system-specified constructor <Fun per="value">Plex</Fun>) applied to the same arguments. Rest variables (<repo> and <resl>) are also permitted. For example:
<Plex>
  <Var>title</Var>
  <Var>author</Var>
  <Var>table of contents</Var>
  <Var>chapters</Var>
</Plex>
See schema docs.

109 <Precedes>

An interval algebra Operation sentence defining a relation between two intervals (<Interval>), here "X precedes Y".
See schema docs.

110 @prefix

an Attribute defining a list of prefixes for the mapping of Compact URIs (Curies) to Internationalized Resource Identifiers (IRIs) as a white space separated list of prefix-name IRI pairs of the form "prefix : xsd:anyURI". Reaction RuleML allows the use of Curies in addition to absolute IRIs in several attributes which act as local or as external identifiers or references (@vocab @type @iri @node @key @keyref). Since Reaction RuleML provides means for including and importing distributed RuleML knowledge bases (<Consult>, XML Inclusions (XInclude)), for interchanging rule bases and questions-answering via messaging (<Send>, <Receive>, <Message>), and for modularizing a knowledge base (@key, @keyref) it must deal with complete IRIs instead of relative paths and local identifiers/references. Any relative IRI, Curie (or local (vocabulary) term) MUST be resolved relative to the @xml:base IRI and the defined prefixes (@prefix) (and vocabularies @vocab for term mapping). The mapping is as follows:
  • TERM (only for @type): is expanded with the defined vocabulary (@vocab) and the resulting IRI is used. If there is no local vocabulary which can be used, check if the term (case-sensitively) matches a name in the local type signature definitions. If there is a match, use the base IRI.
  • CURIE: is translated into an IRI using a prefix (@prefix) and the resulting IRI is used.
  • IRI: the value is already an absolute IRI, and is used as such.

Default prefixes can be explicitly defined on the top level <RuleML> element. If no prefix is defined it will use the @xml:base which will usually be the IRI of the document if no explicit XML base is defined. Reaction RuleML also permits the definition of mappings by XML Namespaces (xmlns). The defined xmlns mappings are processed before processing of any mappings from @prefix on the same attribute value (note, relative paths as the IRI should not be used and must not be evaluated against the XML base). General prefixes defined on <RuleML> can be overwritten by prefix definitions on all elements (e.g. to permit the use of Curies in @key @keyref in imported knowledge as well as on the extensible <content> role, which is used to embed arbitrary XML code as content into the RuleML language). The processing rules for the mapping of Curies into IRIs using the @prefix attribute follow the RDFa processing model. For instance, the modularization example given for the @key attribute defines a key as a Curie (<Rule key="rule-interface">) which is by default expanded to the base IRI or in case a prefix is used (e.g. <Rule key="kb1:rule-interface">) it would be translated into an IRI by the defined prefix mapping.

See schema docs.
(See: RDFa processing model)

111 <Profile>

Metalogical Node for an explicit generic semantic profile defining the intended semantics for knowledge interpretation (e.g. a model-theoretic semantics), inference (e.g. entailment regimes and proof-theories) and execution (e.g. operational semantics, selection and consumption policies) etc., as needed e.g. for rule interchange (see <Message>), knowledge inclusions, imports, updates and querying (see RuleML XInclude includes and performatives/actions (<Assert>, <Retract>, <Consult>, <Query>, <Answer>, <Update>, <Test>, <Send>, <Receive>, <Action>), as well as semantically safe translations from RuleML into platform specific languages for the execution and reasoning. A semantic profile is defined
  • internally by a <formula> role which contains the axioms of the semantics represented in RuleML syntax
  • internally by the <content> role which allows using any XML content model (xs:any), e.g. to embed semantic definitions given in other XML-based languages, e.g. in ISO Common Logic XCL, W3C OWL/XML etc.
  • externally or locally by referencing an existing external or local semantic profile definition, where
    • the optional @type attribute references the local or external sort name/type of the used semantic profile,
    • the optional @iri attribute points to an external definition (resource) of the semantics profile,
    • the optional @keyref attribute syntactically references and co-joins a local profile definition, identified by its corresponding unique key.

The optional @direction attribute indicates the default direction of the inference / execution. The optional @closure attribute indicates the default quantification. The optional @safety attribute indicates if the default execution / inference is transactional, interrupting, non-interrupting. The optional @card @minCard @maxCard attributes act as a generic size boundary / counter in the operational semantic profiles.

Multiple semantic profiles can be used or locally defined as alternatives in the <evaluation> meta role by using the @index attribute in the surrounding <evaluation> role. For example:

   <evaluation index="1">
      <!-- the primary intended semantics is well founded semantics -->
      <Profile type="ruleml:WellFoundedSemantics" direction="backward"/>
    </evaluation>
    <!-- and (alternatively) semantic profile is answer set semantics -->
    <evaluation index="2">
      <Profile type="ruleml:AnswerSetSemantics" direction="backward"/>
    </evaluation>

Defined semantic profiles can be referenced in the @style attribute. For example:

   <Naf style="WellFoundedSemantics AnswerSetSemantics SLDNF ">...</Naf>
See schema docs.

112 <protocol>

An optional Edge in RuleML messages (<Message>) to specify the protocol (<Protocol> which should be used for the message interchange.
See schema docs.

113 <Protocol>

A generic Protocol Node used in CEP Reaction RuleML's message interchange (<Message>) to define protocols (e.g. high-level coordination and negotiation protocols, agent/service protocols, operational message interchange protocols etc.). An protocol can be either defined by arbitrary XML syntax within its <content> role or by references to an external definition using the @type and @iri attribute. Protocol definitions can be used in messaging reaction rules within the protocol (<protocol>) role in a message (<Message>).
See schema docs.

114 <qualification>

An optional Edge used to define qualifying meta knowledge. Examples of qualifying meta knowledge are e.g. validity times, prioritization etc. In contrast to descriptive metadata (<meta>), qualifying metadata has an impact on the semantics, e.g. it used for knowledge prioritization (e.g. in defeasible reasoning, production rules conflict resolution strategies), defining validity times (e.g. for windowing techniques in event processing or knowledge life cycle management such as selection and consumption policies), etc. Such qualifying meta knowledge can be used in guarded scoped meta reasoning (see <scope> and <guard>) to construct dynamic views on the knowledge base (so called scopes) in which the reasoning takes place.
See schema docs.

115 <quantification>

An optional Edge used to define quantifiers (<Quantifier>, <Forall>, <Exists>). Note, Reaction RuleML defines quantifiers internally, i.e. in the formulas in which the quantifier scope applies, whereas Deliberation RuleML (in version 1.0) defines quantifiers in prefix notation it outside of the formulas, which are in the scope of the quantifier.
See schema docs.

116 Quantified Sentence

Compound formula resulting from the application of a quantifier to a formula.
See: <Exists> <Forall>

117 <Quantifier>

Generic Quantified sentence defined internally in the <quantification> role. It consists of one or more variables (<Var>), each optionally surrounded by <declare> role tags, followed by an optional logical <guard> formula (optionally surrounded by <formula> role tags). The sort of the generic Quantifier is defined by the @type attribute and the @iri attribute can be used to point to an external vocabulary definition. For instance, <Forall> is a shortcut of a generic quantifier type using forall quantifier defined in the RuleML metamodel <Quantifier type="ruleml:Forall"> and <Exists> for <Quantifier type="ruleml:Exists">.
See schema docs.

118 <Query>

Performative acting as a wrapper specifying that its content (optionally surrounded by <formula> role tags) is queried, making an 'implicit <Rulebase>' assumption.[1] This allows the separation of declarative content from such procedural performatives (as pioneered by KQML, which has a similar performative 'ask').
See schema docs.

119 <Receive>

An Performative/action that waits to receive an enclosed (<enclosed>) message (<Message>) matching the pattern defined in the message's signature definition (<signature>). The Receive action is used in messaging reaction rules in CEP Reaction RuleML in the event part (<on>). The @card @minCard @maxCard attribute defines the number of messages to be received, with the default value of "1" for exactly one message. If "-1" is used Receive will wait infinitely for incoming messages. The qualification (<qualification> can be used, e.g. to define timeouts and validity intervals.
See schema docs.

120 <receiver>

An optional Edge in RuleML messages (<Message>) to specify the receiving agent (<Agent>) of the message.
See schema docs.

121 <Reify>

Simple term that supports reification (a kind of instantiation or quasi-quotation). It allows any RuleML element available within the current RuleML language as content, treating it as a term for performing reasoning on, e.g.

<Reify><Ind>John Doe</Ind></Reify>

See schema docs.

122 <Rel>

Relation, i.e. logical predicate, of an atom (<Atom>). It is optionally surrounded by operator (<op>) role tags.
See schema docs.

123 Relation

Node indicating the predicate that is applied in an atom (atomic formula).
See <Rel>, <Const>, <Var>, <Uniterm>, <Expr>, <Skolem>, <Reify>, <Data>, <Ind>

124 <repo>

Edge for a positional rest variable used in <Atom>s, <Expr>s and <Plex>s. Note that <Plex>s are generated, so <repo>s are only available above the Datalog sublanguage.
See schema docs.

125 <resl>

Edge for a slotted rest variable used in <Atom>s, <Expr>s and <Plex>s. Note that <Plex>s are generated, so <resl>s are only available above the Datalog sublanguage.
See schema docs.

126 <Retract>

Performative specifying that its content (optionally surrounded by <formula> role tags) is to be deleted, making an 'implicit <Rulebase>' assumption.[1] This allows the separation of declarative content from such procedural performatives (as pioneered by KQML, which has a similar performative 'untell'). For example, if John no longer likes Mary then this fact could be retracted:
 <Retract>
   <Atom>
     <Rel>likes</Rel>
     <Ind>John</Ind>
     <Ind>Mary</Ind>
   </Atom>
 </Retract>
See schema docs.

127 <right>

Edge for the right-hand side of an equation (<Equal>).
See schema docs.

128 <Rule>

A Connective sentence. A rule can be optionally annotated with descriptive metadata (e.g. for life cycle management) using the <meta> role. An optional <scope> with optional additional <guard> constraints can be defined in which reasoning/execution of the rule takes place. The intended semantics of the rule can be defined by one or more semantic <Profile>s which are defined or referenced in the <evaluation> role. There is a distinction into the rule interface signature which is define by the <signature> role and the concrete implementation of a rule defined by its parts (<on>, <if>, <then>, <do>, <after>, <else>, <elseDo>). It is possible to define the interface signature of a rule separated from its implementation by using the @key @keyref attributes. Qualifying metadata (used e.g. for defining a qualified <scope>) is defined in the optional rule <qualification> and quantifications (<Quantifier>, <Forall>, <Exists>) are defined in the <Quantifier> role. The full syntax of a <Rule> is as follows:
<Rule @style? @vocab? @type? @closure? @direction? @material? @safety? @card @minCard @maxCard? @node? @prefix? @key? @keyref? @xml:id? @xml:base? >
     <meta>   <!-– descriptive metadata of the rule -->	       </meta>
     <scope>   <!–- scope of the rule e.g. a rule module -->   </scope>
     <guard>   <!–- a guard constraint acting as pre-condition -->   </guard>
     <evaluation>    <!-- intended semantics -->	       </evaluation>
     <signature> <!– rule signature -->                        </signature>
     <qualification> <!–- e.g. qualifying rule metadata, e.g.
                          priorities, validity, strategy -->	</qualification>
     <quantification>  <!-- quantifying rule declarations,
                            e.g. variable bindings -->	      </quantification>
     <oid>  <!– object identifier -->			      </oid> 
     <on>      <!–- event part -->			      </on>
     <if>      <!–- condition part -->                        </if>
     <then>    <!-– (logical) conclusion part -->             </then>
     <do>      <!--  action part -->			      </do>
     <after>   <!–- postcondition part after action,
                    e.g. to check effects of execution -->    </after>
     <else>  <!–- (logical) else conclusion -->		      </else>
     <elsedo>  <!-- alternative/else action,
                    e.g. for default handling -->	      </elsedo>
</Rule>

By selecting different parts of the syntax a <Rule> can be configured to define different major reaction rule sorts, such as

  • all deliberation rule (DR) types (see Deliberation RuleML 1.0)
  • (temporal/spatial/interval) reasoning derivation rules ("<if> condition <then> conclusion") and knowledge representation (KR) rules in event/action/situation calculi,
  • production rules (PR) ("<if> condition <do> action"),
  • Event-Condition-Action (ECA) rules ("<on> event <if> condition <do> action") and simple trigger rules (EA) ("<on> event <do> action")
  • Complex Event Processing (CEP) rules (arbitrary serial combination of all rule parts) and messaging reaction rules where the events and actions are <Message> interchanged between distributed event-based systems and event processing rule agents. The @style attribute defines the reasoning/execution style with value "reasoning" for purely reasoning rules, "active" for (re-)active rules with active detection and execution and "messaging" for messaging reaction rules which <Send> and <Receive> <Message>s.

The following example shows how a <Rule> by selecting different parts can be configured to a particular rule sort.

Derivation Rule             Production Rule         ECA Rule                     CEP Messaging Rule

<Rule style="reasoning">    <Rule style="active">   <Rule style="active">        <Rule style="messaging">
   <if>...</if>               <if>...</if>            <on> ____ </on>              <on> <Receive> ____ </Receive> </on>
   <then>---</then>           <do>---</do>            <if> ... </if>               <do> <Send> ---- </Send>  </do>
</Rule>                     </Rule>                   <do> ---- </do>              <on><Receive> ____ </Receive></on>
                                                     </Rule>                       <if> ... </if>
                                                                                   <do>  ___  </do>
                                                                                </Rule>

An <Implies> rule is a shortcut notation for <Rule style="reasoning"> with <if>-<then> parts. In addition to these core rule parts an alternative logical conclusion (<else>), post-condition (<after>), and alternative action (<elseDo>) can be defined. In combined Reaction RuleML dialects also mixtures of different rule parts are possible, e.g. a production rule with actions (<do>) and logical conclusion (<then>)

See schema docs.

129 <Rulebase>

Metalogical Node indicating a collection of rules that can be ordered or unordered, without or with duplicates.
See schema docs.

130 <RuleML>

Node for the n-ary top-level of a RuleML document. It permits an (ordered) transaction of n performative (<Assert>, <Query> or <Retract>) invocations, optionally wrapped in <do> role tags, making an 'implicitly sequential' assumption.
See schema docs.

131 @safety

An Attribute defining the execution/processing "safety" of a semantic profile (<Profile>), an action (<Action>, <Assert>, <Retract>, <Update>, <Query>, <Operation>, <Succession>, <Choice>, <Flow>, <Loop>) or an event (<Event>, <Sequence>, <Disjunction>, <Xor>, <Conjunction>, <Concurrent>, <Not>, <Any>, <Aperiodic>, <Periodic>, <AtMost>, <Operation>). It defines if the execution safety is "transactional", i.e. atomic (depending on the transactional semantics of the Profile with roll-backs and/or compensations), "non-interrupting" or "interrupting". The default value is "non-interrupting".
See schema docs.

132 <scope>

An optional Edge role used to define a scope on the knowledge base. A scope is a view on the knowledge base. Scopes (as pioneered in the RBSLA project and implemented in the Prova rule engine) can be dynamically constructed (constructive view) by meta reasoning over the knowledge's metadata (<meta> and <qualification>). Included (XInclude) / imported (<Consult>), messaged (<Message>), asserted/updated (<Assert>), queried (<Query>) and structured (<Rulebase>) knowledge sets are implicitly metadata labelled by their source (typcially a RuleML document) and their unique <@key>. This can be used to manage the knowledge as scoped modules in a knowledge base on which scoped reasoning takes place in a closed domain and for life-cycle management operations, such as retracting (<Retract>) scoped knowledge modules, transactional knowledge base updates (<Retract>) with metadata annotated KB state transitions which can be rolled-back, etc. Further knowledge constraints can be defined explicitly using the <scope> and <guard> roles to construct a knowledge view in which scoped reasoning takes place in an explicitly closed domain.

For instance, the following example defines (in Prova syntax) three event facts event(e1), event(e2) and event(e3). These facts are annotated with additional metadata labels describing their source @src, @author and @key. Knowledge from source "kb1.rrml" is defined as a trusted source (trusted(example.org/kb1.rrml). The event selection rule (select(Event)) in its if body defines one scoped condition literal (event(Event)) with a scope defined over all knowledge sources (@src(Source) which are authored by "Adrian Paschke" (@author("Adrian Paschke")). This scope dynamically constructs a view on the knowledge base selecting event "e1" and "e3", but not "e2" since "e2" it is authored by "John Doe" and not "Adrian Paschke". The additional pre-conditional guard ([trusted(Source)]) then constraints the knowledge in the scope to only trusted knowledge sources, which is only event "e1" but not "e3" since "e3" comes from an untrusted source, i.e., the constructed guarded scope only consists of the remaining knowledge fact event(e1) on which the condition event(Event) is applied as a goal in backward-reasoning.

@src(http://example.org/kb1.rrml) @author("Adrian Paschke") @key(e1) event(e1).
@src(http://example.org/kb1.rrml) @author("John Doe") @key(e2) event(e2).
@src(http://example.org/kb2.rrml) @author("Adrian Paschke") @key(e3) event(e3).

trusted(http://example.org/kb1.rrml).

select(Event) :- @src(Source) @author("Adrian Paschke") event(Event) [trusted(Source)].

The corresponding scope and guard definitions in Reaction RuleML are:

<scope>
<And>
  <Atom><Rel>src</Rel><Var>Source</Var></Atom>
  <Atom><Rel>author</Rel><Ind>Adrian Paschke</Ind></Atom>
</And>
</scope>
<guard>
<Atom><Rel>trusted</Rel><Var>Source</Var></Atom>
</guard>

A particular application of scopes in Reaction RuleML is the life cycle management of (active) knowledge in complex event and action processing. The scoping mechanism can be used, e.g., for defining certain selection and consumption policies (e.g. disqualify already processed events with a metadata flag and exclude them from the active processing/reasoning scope and retract all processed events from the knowledge bases after the complex event detection") or e.g., for implementing (sliding) windowing techniques using the event metadata (e.g. "events not older than ...").

See schema docs.

133 @scope

Attribute referencing a predefined or user defined <scope>. Predefined scopes are "global", "local" and "private".
See schema docs.

134 <sender>

An optional Edge role in RuleML messages (<Message>) to specify the sending agent (<Agent>) of the message.
See schema docs.

135 <Send>

A Performative/action that sends an enclosed (<enclosed>) message (<Message>). The Send action is used in messaging reaction rules in CEP Reaction RuleML in the action part (<do> <elseDo>).
See schema docs.

136 <Sequence>

An event algebra Operation sentence defining a sequence operation ("sequence of events") for an ordered sequence of events (<Event>, <Sequence>, <Disjunction>, <Xor>, <Conjunction>, <Concurrent>, <Not>, <Any>, <Aperiodic>, <Periodic>, <AtMost>, <AtLeast>, <Operation>).
See schema docs.


137 <signature>

An optional Edge role used for signature definitions of knowledge in a knowledge base. The signature definition can be defined separately by using key-keyref referencing (see @key) separating the knowledge interface (which includes the signature definition) from the concrete implementation / instantiation. Signatures are used for defining type signatures (e.g. a frame type signatures) and template patterns (e.g. query patterns, event patterns, message patterns). For instance, the following example defines the signature for a 2-ary predicate "likes" with the first argument being an input argument (i.e. a bound value) and the second argument being an output argument (i.e. a free variable).
<signature>
<Atom>
  <Rel>likes</Rel>
  <Var mode="+"/> <!-- mode=+ i.e. input argument -->
  <Var mode="-"/> <!-- mode=- i.e. output argument -->
</Atom>
</signature>

This example shows the definition of a frame signature for a frame type "person", who "likes" all types of "wine".

<signature>
   <Atom>
     <oid><Ind>person</Ind></oid>
     <slot><Ind>likes</Ind><Var type="wine" mode="?"/></slot>
   </Atom>
</signature>

This example defines the event pattern signature for a complex event pattern "(a;(b;c))" (which can be used e.g. in the <on> part of a ECA or CEP Reaction <Rule> for detecting instances of such complex event pattern signature).

<signature>
  <Event type="ruleml:ComplexEvent">
   <Sequence>
     <Event type="ruleml:SimpleEvent"> <!-- event "a"--> </Event>
     <Sequence>
       <Event type="ruleml:SimpleEvent"> <!-- event "b" --> </Event>
       <Event type="ruleml:SimpleEvent"> <!-- event "c" --> </Event>
     </Sequence>
   </Sequence>
</Event>
</signature>
See schema docs.

138 Simple Formula

Formula that may not contain other formulas.
See <Atom> <Equal>

139 Simple Term

Term that may not contain other terms.
See: <Data>, <Ind>, <Skolem>, <Var>, <Reify>, <Const>

140 <Situation>

Explicit generic Situation Node. A situation can be defined

  • with positional arguments (with <arg>)
  • with unpositional slots (with <slot>)
  • by a complex term (with <Expr>)
  • by interpretation of intervals, time, spatial or event/action as situation
  • as a frame object (with <oid> and <slot>)
  • by <content>, which acts as an extension point to embed one of the many existing XML serialization languages for events
  • by external reference using the @iri attributes
  • by internal reference using the @key @keyref attributes

The optional @type attribute defines the type of the situation. The RuleML Metamodel distinguishes the top-level sorts "HomogenousSituation" and "HeterogenousSituation" and "Fluent" which are conditional situation (effects) that can change.

Like Uniterms the interpretation of a Situation as object (situation individual), relation, (complex) term, function and its model-theoretic truth interpretation, is context sensitive on where it is used in a formula and depends on the reasoning/execution @style of the Reaction RuleML dialect and the intended semantic interpretation/execution <Profile>. For instance, in non-reified calculi situations and fluents are represented as predicates while in reified calculi fluents can be represented as functions. The @per attribute can be used to explicitly define the intended interpretation of embedded situation functions (<Expr>).

See schema docs.

141 <Skolem>

Simple term that is a Skolem individual constant.[4]
See schema docs.

142 <slot>

A user-defined slot consisting of a name (first position) and a filler (second position). For example:
<slot>
  <Ind>color</Ind>
  <Ind>blue</Ind>
</slot>
See schema docs.


143 <Spatial>

Explicit generic Spatial Node. The optional @type attribute defines the type of the spatial.

A spatial can be defined:

  • with positional arguments (with <arg>)
  • with unpositional slots (with <slot>)
  • by a spatial expression function (with <Expr>)
  • as a frame object (with <oid> and <slot>)
  • by <content>, which acts as an extension point to embed one of many existing of times
  • by external reference using the @iri attributes
  • by internal reference using the @key @keyref attributes on existing time definitions
  • by an absolute or relative spatial algebra operator (<After>, <Before>, <Every>, <Any>, <Operation>)
See schema docs.

144 <Starts>

An interval algebra Operation sentence defining a relation between two intervals (<Interval>), here "X starts Y".
See schema docs.

145 <strong>

Edge for a role used for classical negation (<Neg>).
See schema docs.

146 @style

Attribute indicating a predefined or user-defined semantic profile or supported set of entailments (partially) defining the intended semantics. Predefined semantic profiles are indicated by CURIEs or IRIs in the http://ruleml.org/profiles/ namespace, predefined entailment sets are indicated by CURIEs or IRIs in the http://ruleml.org/entailments/ namespace, and user-defined semantic profiles are indicated by CURIEs or IRIs in namespaces that do not use the domain "ruleml.org" or any of its subdomains. Collectively, profiles and entailment sets are called semantic styles, or simply styles if the context is clear.
  • A Node without a style attribute inherits the style of its parent Node.
  • A Node with one or more semantic variant attributes is interpreted according to a modification of its semantic style per the specification of the semantic variant attribute values. However, the semantic style of the Node is not modified, so that its descendants may inherit the unmodified style.
  • A RuleML document with no style attributes has ambiguous semantics. This corresponds to a supported set of entailments that includes only reflexive entailments (i.e. every theory entails itself).
  • A RuleML document should reference only semantic styles that are compatible with each other. The style definitions should specify the nature of their compatibility and the mechanism for determining entailments of theories with multiple compatible styles. See the section Predefined Semantic Styles in the Specification of Reaction RuleML 1.02 for further details.
See schema docs.


147 <Succeeds>

An interval algebra Operation sentence defining a relation between two intervals (<Interval>), here "X succeeds Y".
See schema docs.

148 <Succession>

An action algebra Operation sentence defining a succession operation for an ordered execution of actions (<Action>, <Assert>, <Retract>, <Update>, <Query>, <Operation>, <Succession>, <Choice>, <Flow>, <Loop>).
See schema docs.

149 <Terminates>

a generic predicate Node used in reified calculi for event/action/situation/fluent reasoning (e.g. event calculus, situation calculus, fluent calculus, etc.). The Terminates predicate defines when a fluents (<Fluent>) is initiated by an event/action(<Event>, <Action>) at a time (explicit <Time>, as e.g. in event calculus and temporal situation calculus, or a history of <Situation>s, as e.g., in classical situation calculus). Different sorts of the terminates predicates can be defined by reference to an external vocabulary with the @iri attribute.
See schema docs.

150 Term

Node that may be an operand in simple formulas or compound terms.
Subcategories: Simple Term, Compound Term

151 <Test>

A Performative/action wrapper for Verification, Validation and Integrity testing (VVI - as implemented in the ContractLog framework of the RBSLA project and used in RuleResponder agent architecture for self-validating rule interchange). It consists of VVI tests (integrity entailments (<Entails>), single test items (<TestItem>) or possibly nested test suites (<TestSuite>) and is optionally surrounded by role tags (<vvi>) which might be ordered (@index). The following example shows the typical template of a test.
<Test>
	<vvi>
		<TestSuite>
			<!-- semantic profiles which should be us for the test suite -->
			<evaluation><Profile></Profile></evaluation>
			<!-- test assertion base, such as ground test facts -->
			<testbase><Assert></Assert></testbase>
			<vvi>
				<!-- one particular test item of a test suite -->
				<TestItem>
					<!-- test query -->
					<act><Query></Query></act>
					<!-- exepected result -->
					<expectedResult>
						<Answer>
							<degree><Data>1</Data></degree> <!-- expected "1" = query succeeds -->
							<!-- resulting query variable bindings  -->
							<Equal></Equal> 
							<Equal></Equal>	
							<Equal></Equal>	
						</Answer>
					</expectedResult>
				</TestItem>
			</vvi>
		</TestSuite>
	</vvi>
</Test>

An optional scope (<scope>) can be defined so that the test applies only to the scope (constructive view) on the knowledge base.

See schema docs.

152 <testbase>

Edge role used to define the test base for for a testsuite (<TestSuite>) consisting of either test assertions (<Assert>) or a consulted external test base (<Consult>).
See schema docs.

153 <TestItem>

a TestItem Metalogical Node describes one particular <vvi>-test consisting of the test <do> (typically a <Query>) and the expected result (<expectedResult>) (an <Answer> containing the expected truth valuation (<degree>) and the results/variable bindings).
See schema docs.

154 <TestSuite>

a TestSuite Metalogical Node consisting of test assertions (<Assert>) (typically ground test facts (<Atom>) and test events (<Event>)) and/or consulted external test bases (<Consult>) and a number of <vvi>-tests (integrity <Entails>s, <TestItem>s or other nested <TestSuite>s).
See schema docs.

155 <then>

The "then" Edge part of a rule (<Rule>) containing the conclusion, also known as the "consequent" or "head" of the rule. Also used as the "consequent" part of an entailment (<Entails>).
See schema docs.

156 <Time>

Explicit generic Time Node. A time can be defined:

The optional @type attribute defines the type of the time, e.g. the RuleML Metamodel predefines "TimeInstant" (linear continuous time model with points in time called time instants) or "TimePoint" and "TimeInterval" (discrete time interval model with time points and time intervals). The default time semantics is a discrete time model. A time can be defined absolute or relative.

See schema docs.

157 <Timer>

An algebra Operation sentence defining a time (<Time>) or spatial (<Spatial>) which is described by a recurring time or space counter. A timer is a syntactic shortcut for "After X Every Y", e.g. "after 1 hour every minute" (recurring timer).
See schema docs.

158 <torso>

Edge for a symmetric role used in an equivalence formula (<Equivalent>) combining the asymmetric <then> and <if>.
See schema docs.

159 @type

Attribute for optionally specifying a term (user-defined) type.
See schema docs.

160 <Uniterm>

Node that is a function, relation, compound term or simple formula represented as a Hilog term, generalizing <Atom> and <Expr>.

161 <Update>

An update Performative/action which executes an update of the knowledge base. Update actions can be used as performatives and as complex actions in the <do> role of a reaction rule. The optional @card @minCard @maxCard attributes define the exact, minimum, maximum number of internal action executions with the default value -1 = unlimited. With the optional @safety attribute it can be defined if the complex action execution should be transactional (i.e. an atomic execution), interrupting or non-interrupting. A transactional update (<Update safety="transactional">) is equivalent to an atomic execution of retract (<Retract>) followed by assert (<Assert>).

The following examples updates a rulebase "kb1" with another rulebase "kb2".

<Update>
  <Rulebase keyref="kb1"/>
  <Rulebase keyref="kb2"/>
</Update>

The next example replaces a rule with another rule.

<Update>
  <Rule>
    <if><Atom><Rel>likes</Rel><Var>X</Var><Ind>wine</Ind></Atom></if>
    <then><Atom><Rel>likes</Rel><Ind>John</Ind><Var>X</Var></Atom></then>
  </Rule>
  <Rule>
    <if><Atom><Rel>likes</Rel><Var>X</Var><Ind>beer</Ind></Atom></if>
    <then><Neg><Atom><Rel>likes</Rel><Ind>John</Ind><Var>X</Var></Atom></Neg></then>
  </Rule>
</Update>

The third example uses place holder variables which are substituted by variable bindings defined in the equations of the update rulebase.

<Update>
  <Rule>
    <if><Atom><Rel>likes</Rel><Var>_1</Var><Var>_2</Var></Atom></if>
    <then><Atom><Rel>likes</Rel><Var>_3</Var><Var>_1</Var></Atom></then>
  </Rule>
  <Rulebase>
    <Equal oriented="yes"><Var>_1</Var><Var>X</Var></Equal>
    <Equal oriented="yes"><Var>_2</Var><Ind>wine</Ind></Equal>
    <Equal oriented="yes"><Var>_3</Var><Ind>John</Ind></Equal>
  </Rulebase>
</Update>

And the last example shows an update of the "likes" slot value of a an existing frame modifying it from "wine" (the existing value; not shown here) to "beer".

<Update>
<Atom>
  <oid><Ind>Mary</Var></oid>
  <slot><Ind>likes</Ind><Ind>beer</Ind></slot>
</Atom>
</Update>

Scoped reasoning (see <scope>) can be used in Update to constrain the update to a particular scope (constructed view) of the knowledge base.

See schema docs.

162 @val

Semantic variant Attribute used to indicate whether a function (<Fun>) is deterministic or non-deterministic.[3] It has two values: "1" (deterministic: exactly one) and "0.." (set-valued: zero or more). For example, the function children(John, Mary) can be interpreted in a set-valued manner using a definition children(John, Mary) = {Jory, Mahn}, so that the application children(John, Mary) returns {Jory, Mahn}:
<Expr>
  <Fun per="value" val="0..">children</Fun>
  <Ind>John</Ind>
  <Ind>Mary</Ind>
</Expr>
See schema docs.

163 <Var>

Simple term (or, in Holog languages, function or relation) that is a logical variable, as in logic programming.
See schema docs.

164 @vocab

Attribute with an Internationalized Resource Identifier (IRI) that defines the mapping to be used when a term is referenced in an @type attribute value. This makes the @type attribute term values fully "webized", even in case of the use of local type definitions such as frame type signatures (<signature>). A default vocabulary can be explicitly defined on the top level <RuleML> element. If no vocabulary is defined it will use the @xml:base which will usually be the IRI of the document if no explicit XML base is defined. The default vocabulary can be overwritten by vocabulary definitions on all elements where the @type can be used and on the extensible <content> role, which are used to embed arbitrary XML code as content into RuleML. The processing rules for the mapping of terms into IRIs using the @vocab attribute follow the RDFa processing model:
  • If the value is a term then it is evaluated as a term as follows:
    • If there is a local default vocabulary the IRI is obtained by concatenating that value and the term.
    • Otherwise, check if the term matches a type name in the type signature definitions (<signature>). If there is a match, use the base IRI.
  • If the value is a valid CURIE, then use the prefix (or the XML base IRI if there is no default prefix) to map the Curie into an IRI.
  • If the value is an absolute IRI, that value is used.
  • Otherwise, the value is ignored.

The following example defines a time frame signature "Datetime" (<oid><Ind>Datetime</Ind></oid>'), where the Time frame is of type type="TimePoint", which maps into the default RuleML vocabulary and the two frame slots "date" and "time" have a value space of type type="date" and type="time", where the used type terms are mapped by the vocab="https://www.w3.org/2001/XMLSchema" into the XML schema vocabulary.

<signature>
	<Time type="TimePoint">
		<oid><Ind>Datetime</Ind></oid>
		<slot><Ind>date</Ind><Var vocab="https://www.w3.org/2001/XMLSchema" type="date"/></slot>
		<slot><Ind>time</Ind><Var vocab="https://www.w3.org/2001/XMLSchema" type="time"/></slot>
	</Time>
</signature>
See schema docs.

165 <vvi>

a "Verification-Validation-Integrity" (vvi) Edge role used in the test action/primitive (<Test>) and in test suites (<TestSuite>) for VVI tests (integrity entailments (<Entails>), single test items (<TestItem>) or possibly nested test suites (<TestSuite>).
See schema docs.

166 <weak>

Edge for a role used for negation as failure (<Naf>).
See schema docs.

167 @weight

Semantic variant Attribute optionally specifying a <slot>'s relative weight.
See schema docs.

168 <Xor>

An event algebra Operation sentence ("event 1 xor event 2") defining a mutual exclusive set of events (<Event>, <Sequence>, <Disjunction>, <Xor>, <Conjunction>, <Concurrent>, <Not>, <Any>, <Aperiodic>, <Periodic>, <AtMost>, <AtLeast>, <Operation>).
See schema docs.
  1. 1.0 1.1 1.2 http://ruleml.org/fol FOL RuleML
  2. http://image.ntua.gr/FuzzyRuleML Fuzzy RuleML
  3. 3.0 3.1 http://ruleml.org/fun Functional Ruleml
  4. http://ruleml.org/posl/poslintweb-talk.pdf Integrating Positional and Slotted Knowledge on the Semantic Web slides