Reaction RuleML 0.1 Syntax

Reaction RuleML 0.2 Syntax

Quick Links:
EBNF Syntax, Content Models, Meta Models

The syntax of Reaction RuleML is specified by means of extended BNF (EBNF), i.e. alternatives are separated by vertical bars (|); zero to one occurrences are written in square brackets ([]) and zero to many occurrences in braces ({}).

RuleML 0.91 Layer (RuleML hornlogeq.xsd)

see RuleML 0.91 content models

Derivation RuleML Layer (dr.xsd)

Derivation Rules with Naf, Neg, Equal and optional meta data label, scope and rule quantification; Replaces "Implies" with general "Rule"

RuleML ::= [label,] [scope,] [quantification,] [oid,] {Assert | Retract | Query}
Assert ::= [label,] [scope,] [quantification,] [oid,]
                {formula | Rulebase | Atom | Rule | Equivalent | Entails | Forall | Equal | Neg}
Retract ::= Assert
Query ::= [label,] [scope,] [quantification,] [oid,] {formula | Rulebase | Naf | Neg | Atom | And | Or | Entails | Exists | Equal}
Rulebase ::= [label,] [scope,] [quantification,] [oid,]
                   {formula | Atom | Neg | Rule | Equivalent | Equal | Forall}
Atom ::= [label,] [scope,] [quantification,] [oid,] (op | Rel,) {slot,}
              {arg | Ind | Data | Skolem | Var | Reify,} {slot}
Expr ::= [label,] [scope,] [quantification,] [oid,] (op|Fun,) {slot,} [resl,]
             {arg|Ind|Data|Skolem|Var|Reify|Expr|Plex,} [repo,] {slot,} [resl]

PR RuleML Layer (pr.xsd)

Production Rules and Serial Derivation Rules with transactional update actions (Assert, Retract, Update)

Rule ::= [label,] [scope,] [quantification,] [oid,]
            (if, do, [after,] [else,] [elseDo,] [elseAfter]) |
            (if, then, [else,] [elseDo,] [elseAfter])
if ::= Atom | And | Or | Equal | Naf | Neg | Assert | Retract | Update
do ::= {Atom | Assert | Retract | Update | Rule}
after ::= if
elseDo ::= do
elseAfter ::= if
Update::= (oid | formula | Rulebase | Atom | Rule | Equivalent | Entails | Forall | Equal | Neg,)
                [oid | formula | Rulebase | Atom | Rule | Equivalent | Entails | Forall | Equal | Neg]

RR RuleML Layer (rr.xsd)

Reaction Rules with complex event and action algebra operators and messaging reaction rules with complex event messages

RuleML ::= [label,] [scope,] [quantification,] [oid,] {Assert | Retract | Query,} [Message]
Rule ::= [label,] [scope,] [quantification,] [oid,]
            (on, [if,] [then,] do, [after,] [else,] [elseDo,] [elseAfter]) |
            (on | do) |
            (if, do, [after,] [else,] [elseDo,] [elseAfter]) |
            (if, then, [else,] [elseDo,] [elseAfter])
on ::= Naf | Neg | Atom | Rule | Message | Sequence | Disjunction | Xor | Conjunction | Concurrent | Not | Any | Aperiodic | Periodic | Ind | Var | Expr
do ::= Atom | Assert | Retract | Update | Message | Succession | Choice | Flow | Loop | Ind | Var | Expr

Message Constructs (message_module.xsd)

Message ::= [label,] [scope,] [qualification,] (oid | Ind | Var | Expr), (protocol | Ind | Var | Expr), (sender | receiver | Ind | Var | Expr), (content | Atom | Ind | Var | Expr | Plex | Naf | Neg | Rulebase | And | Or | Entails | Exists | Equal)
protocol ::= Ind | Var | Expr
sender ::= Ind | Var | Expr
receiver ::= sender
content ::= Atom | Ind | Var | Expr | Plex | Naf | Neg | Rulebase | And | Or | Entails | Exists | Equal

Time and Event Interval Constructs (algebra_module.xsd)

Complex Event and Action Algebra Constructs (algebra_module.xsd)

Complex Event Algebra:
Sequence ::= [oid,] {on | Naf | Neg | Atom | Rule | Message | Ind | Var | Expr | Sequence | Disjunction | Xor | Conjunction | Concurrent | Not | Any | Aperiodic | Periodic }
Disjunction ::= [oid,] {on | Naf | Neg | Atom | Rule | Message | Ind | Var | Expr | Sequence | Disjunction | Xor | Conjunction | Concurrent | Not | Any | Aperiodic | Periodic }
Conjunction ::= [oid,] {on | Naf | Neg | Atom | Rule | Message | Ind | Var | Expr | Sequence | Disjunction | Xor | Conjunction | Concurrent | Not | Any | Aperiodic | Periodic}
Xor ::= [oid,] {on | Naf | Neg | Atom | Rule | Message | Ind | Var | Expr | Sequence | Disjunction | Xor | Conjunction | Concurrent | Not | Any | Aperiodic | Periodic}
Concurrent::= [oid,] {on | Naf | Neg | Atom | Rule | Message | Ind | Var | Expr | Sequence | Disjunction | Xor | Conjunction | Concurrent | Not | Any | Aperiodic | Periodic}
Not::= [oid,] on | Naf | Neg | Atom | Rule | Message | Ind | Var | Expr | Sequence | Disjunction | Xor | Conjunction | Concurrent | Not | Any | Aperiodic | Periodic, interval | Interval | Plex | Var
Any ::= [oid,] Ind | Data | Var, on | Naf | Neg | Atom | Rule | Message | Ind | Var | Expr | Sequence | Disjunction | Xor | Conjunction | Concurrent | Not | Any | Aperiodic | Periodic, interval | Interval | Plex | Var
Aperiodic ::= [oid,] on | Naf | Neg | Atom | Rule | Message | Ind | Var | Expr | Sequence | Disjunction | Xor | Conjunction | Concurrent | Not | Any | Aperiodic | Periodic, interval | Interval | Plex | Var
Periodic ::= [oid,] time | Ind | Var | Expr , interval | Interval | Plex | Var

Complex Action Algebra:
Succession ::= [oid,] {do | Atom | Assert | Retract | Update | Message | Ind | Var | Expr | Succession | Choice | Flow | Loop}
Choice ::= [oid,] {do | Atom | Assert | Retract | Update | Message | Ind | Var | Expr | Succession | Choice | Flow | Loop}
Flow ::= [oid,] {do | Atom | Assert | Retract | Update | Message | Ind | Var | Expr | Succession | Choice | Flow | Loop}
Loop ::= [oid,] {do | Atom | Assert | Retract | Update | Message | Ind | Var | Expr | Succession | Choice | Flow | Loop}

KR Temporal / Event / Action / Transition / Process Logics Layer (kr.xsd)

State Processing Constructs (state_module.xsd)

state ::= Ind | Var | Expr
Initiates ::= [oid,] state | Ind | Var | Expr
Terminates ::= [oid,] state | Ind | Var | Expr
HoldsState: [oid,] (state | Ind | Var | Expr), (time | interval | Ind | Expr | Interval)

Reaction RuleML 0.2 Content Models

The content models are specified in a DTD like notation

RuleML 0.91 Layer (RuleML hornlogeq.xsd)

see RuleML 0.91 content models

Derivation RuleML Layer (dr.xsd)

Derivation Rules with Naf, Neg, Equal and optional meta data label and rule quantification; Replaces "Implies" with general "Rule"

PR RuleML Layer (pr.xsd)

Production Rules and Serial Derivation Rules with transactional update actions (Assert and Retract)

Attributes:
do, elseDo, elseAfter: @arg; possible values: String; optional attribute
Assert: @safety; possible values: transactional|normal; default value: normal; optional attribute
            @all; possible values: yes|no; default value=no; optional attribute
Retract: @safety; possible values: transactional|normal; default value: normal; optional attribute
             @all; possible values: yes|no; default value=no; optional attribute
Update: @safety; possible values: transactional|normal; default value: normal; optional attribute
             @all; possible values: yes|no; default value=no; optional attribute

RR RuleML Layer (rr.xsd)

Reaction Rules with complex event and action algebra operators and messaging reaction rules with complex event messages

Attributes:
on: @arg; possible values: String; optional attribute

Message Constructs (message_module.xsd)

Message: label?, scope?, quantification?, (oid | Ind | Var | Expr), (protocol | Ind | Var | Expr), (sender | receiver | Ind | Var | Expr), (content | Atom | Ind | Var | Expr | Plex | Naf | Neg | Rulebase | And | Or | Entails | Exists | Equal)
protocol: (Ind | Var | Expr)
sender: (Ind | Var | Expr)
receiver: (Ind | Var | Expr)
content: (Atom | Ind | Var | Expr | Plex | Naf | Neg | Rulebase | And | Or | Entails | Exists | Equal)

Attributes:
Message: @mode; possible values: inbound | outbound; required attribute
Message: @directive; possible values: performatives, e.g. ACL:inform; required attribute

Time and Event Interval Constructs (algebra_module.xsd)

Complex Event and Action Algebra Constructs (algebra_module.xsd)

KR Temporal / Event / Action / Transition / Process Logics Layer (kr.xsd)

State Processing Constructs (state_module.xsd)

state: (Ind | Var | Expr)
Initiates: (oid?, (state | Ind | Var | Expr))
Terminates: (oid?, (state | Ind | Var | Expr))
HoldsState: (oid?, (state | Ind | Var | Expr), (time | interval | Ind | Var | Expr | Interval) )