RIF Production Rule Dialect

(* ex1:CheckoutRuleset *)
Group rif:forwardChaining (

  (* ex1:GoldRule *)
  Group 10 (
    Forall ?customer such that (And( ?customer # ex1:Customer
                                     ?customer[ex1:status->"Silver"] ) )
      (Forall ?shoppingCart such that (?customer[ex1:shoppingCart->?shoppingCart])
         (If Exists ?value (And( ?shoppingCart[ex1:value->?value]
                                 pred:numeric-greater-than-or-equal(?value 2000))
          Then Do( Modify( ?customer[ex1:status->"Gold"] ) ) ) )

  (* ex1:DiscountRule *)
  Group (
    Forall ?customer such that (And( ?customer # ex1:Customer ) )
      (If Or (?customer[ex1:status->"Silver"]
              ?customer[ex1:status->"Gold"] )
       Then Do( (?s ?customer[ex1:shoppingCart->?s])
                (?v ?s[ex1:value->?v])
                Modify( ?s[ex1:value->func:numeric-multiply(?v 0.95)] ) ) ) )

To see how the rule set works, consider the case of a shop where the checkout processing of customer John is about to start. The initial state of the fact base can be represented as follows:

Formally, a production rule system is defined as a labeled terminal transition system (e.g. PLO04), for the purpose of specifying the semantics of a RIF-PRD rule or group of rules.

Definition (labeled terminal transition system): A labeled terminal transition system is a structure {C, L, →, T}, where

• C is a set of elements, c, called configurations, or states;
• L is a set of elements, a, called labels, or actions;
• → ⊆ C × L × C is the transition relation, that is: (c, a, c' ) ∈ → iff there is a transition labeled a from the state c to the state c' . In the case of a production rule system: in the state c of the fact base, the execution of action a causes a transition to state the c' of the fact base;
• T ⊆ C is the set of final states, that is, the set of all the states c from which there are no transitions: T = {c ∈ C | ∀ a ∈ L, ∀ c' ∈ C, (c, a, c') ∉ →}.   ☐

For many purposes, a representation of the states of the fact base is an appropriate representation of the states of a production rule system seen as a transition system. However, the most widely used conflict resolution strategies require information about the history of the system, in particular with respect to the rule instances that have been selected for execution in previous states. Therefore, each state of the transition system used to represent a production rule system must keep a memory of the previous states and the rule instances that where selected and triggered the transition in those states.

To avoid confusion between the states of the fact base and the states of the transition system, the latter will be called production rule system states.

Definition (Production rule system state). A production rule system state (or, simply, a system state), s, is characterized by

• a state of the fact base, facts(s);
• if s is not the initial state: a previous system state, previous(s), such that, given two system states s₁ and s₂, s₁ = previous(s₂) if and only if the sequential execution of the action parts of the rule instances in picked(s₁) transitioned the system from system state s₁ to system state s₂;
• if s is not the current state: the ordered set of rule instances, picked(s), that the conflict resolution strategy picked, among the set of all the rule instances that matched facts(s).   ☐

Here, a rule instance is defined as the result of the substitution of constants for all the rule variables in a rule.

In the following, we will write previous(s) = NIL to denote that a system state s is the initial state.

Let R denote the set of all the rules in the rule language under consideration.

Definition (Rule instance). Given a rule, r ∈ R, and a ground substitution, σ, such that CVar(r) ⊆ Dom(σ), where CVar(r) denotes the set of the rule variables in r, the result, ri = σ(r), of the substitution of the constant σ(?x) for each variable ?x ∈ CVar(r) is a rule instance (or, simply, an instance) of r.  ☐

Given a rule instance ri, let rule(ri) identify the rule from which ri is derived by substitution of constants for the rule variables, and let substitution(ri) denote the substitution by which ri is derived from rule(ri).

In the following, two rule instances ri₁ and ri₂ of a same rule r will be considered different if and only if substitution(ri₁) and substitution(ri₂) substitute a different constant for at least one of the rule variables in CVar(r).

In the definition of a production rule system state, a rule instance, ri, is said to match a state of a fact base, w, if its defining substitution, substitution(ri), matches the RIF-PRD condition formula that represents the condition of the instantiated rule, rule(ri), to the set of ground atomic formulas that represents the state of facts w.

Let W denote the set of all the possible states of a fact base.

Definition (Matching rule instance). Given a rule instance, ri, and a state of the fact base, w ∈ W, ri is said to match w if and only if one of the following is true:

• rule(ri) is an unconditional action block;
• rule(ri) is a conditional action block: If condition, Then action, and substitution(ri) matches the condition formula condition to the set of ground atomic condition formulas that represents w;
• rule(ri) is a rule with variable declaration: Forall ?v₁...?v_n (p₁...p_n) (r'), n ≥ 0, m ≥ 0, and substitution(ri) matches each of the condition formulas p_i, 0 ≤ i ≤ m, to the set of ground atomic condition formulas that represents w, and the rule instance ri' matches w, where rule(ri') = r' and substitution(ri') = substitution(ri).   ☐

Definition (Conflict set). Given a rule set, RS ⊆ R, and a system state, s, the conflict set determined by RS in s is the set, conflictSet(RS, s) of all the different instances of the rules in RS that match the state of the fact base, facts(s) ∈ W.   ☐

The rule instances that are in the conflict set are, sometimes, said to be fireable.

In each non-final state, s, of a production rule system, a subset, picked(s), of the rule instances in the conflict set is selected and ordered; their action parts are instantiated, and the resulting sequence of ground atomic actions is executed. This is sometimes called: firing the selected instances.

Definition (Action instance). Given a system state, s, given a rule instance, ri, of a rule in a rule set, RS, and given the action block in the action part of the rule rule(ri): Do((v₁ p₁)...(v_n p_n) a₁...a_m), n ≥ 0, m ≥ 1, where the (v₁ p₁), 0 ≤ i ≤ n, represent the action variable declarations and the a_j, 1 ≤ j ≤ m, represent the sequence of atomic actions in the action block; if ri is a matching instance in the conflict set determined by RS in system state s: ri ∈ conflictSet(RS, s), the substitution σ = substitution(ri) is extended to the action variables v₁...v_n, n ≥ 0, in the following way:

• if the binding, p_i, associated to v_i, in the action variable declaration, is the declaration of a new frame object: (v_i New()), then σ(v_i) = c_new, where c_new is a constant of type rif:IRI that does not occur in any of the ground atomic formulas in the set that represents facts(s), the state of the fact base that is associated to s;
• if v_i is assigned the value of a frame's slot by the action variable declaration: (v_i o[s->v_i]), then σ(v_i) is a constant such that the subtitution σ matches the frame formula o[s->v_i] to the state of the fact base facts(s).

The sequence of ground atomic actions that is the result of substituting a constant for each variable in the atomic actions of the action block of the rule instance, ri, according to the extended substitution, is the action instance associated to ri.   ☐

Let actions(ri) denote the action instance that is associated to a rule instance ri. By extension, given an ordered set of rule instances, ori, actions(ori) denotes the sequence of ground atomic actions that is the concatenation, preserving the order in ori, of the action instances associated to the rule instances in ori.

All the elements that are required to define a production rule system as a labeled terminal transition system have now been defined.

Definition (RIF-PRD Production Rule System). A RIF-PRD production rule system is defined as a labeled terminal transition system PRS = {S, A, →_PRS, T}, where :

• S is a set of system states;
• A is a set of transition labels, where each transition label is a sequence of ground RIF-PRD atomic actions;
• The transition relation →_PRS ⊆ S × A × S, is defined as follows:
  ∀ (s, a, s' ) ∈ S × A × S, (s, a, s' ) ∈ →_PRS if and only if all of the following hold:
  1. (facts(s), a, facts(s')) ∈ →^*_RIF-PRD, where →^*_RIF-PRD denotes the transitive closure of the transition relation →_RIF-PRD that is determined by the specification of the semantics of the atomic actions supported by RIF-PRD;
  2. a = actions(picked(s));
• T ⊆ S, a set of final system states.   ☐

Intuitively, the first condition in the definition of the transition relation →_PRS states that a production rule system can transition from one system state to another only if the state of facts in the latter system state can be reached from the state of facts in the former by performing a sequence of ground atomic actions supported by RIF-PRD, according to the semantics of the atomic actions.

The second condition states that the allowed paths out of any given system state are determined only by how rule instances are picked for execution, from the conflict set, by the conflict resolution strategy.

The execution of a rule set, RS, in a state, w, of a fact base, may result in zero, one or more final state of the fact base, w' = facts(s'), depending on the conflict resolution strategy and the set of final system states.

Therefore, the behavior of a RIF-PRD production rule system also depends on:

1. the conflict resolution strategy, that is, how rule instances are precisely selected for execution from the rule instances that match a given state of the fact base, and
2. how the set T of final system states is precisely defined.

The process of selecting one or more rule instances from the conflict set for firing is often called: conflict resolution.

In RIF-PRD the conflict resolution algorithm (or conflict resolution strategy) that is intended for a set of rules is denoted by a keyword or a set of keywords that is attached to the rule set. In this version of the RIF-PRD specification, a single conflict resolution strategy is specified normatively: it is denoted by the keyword rif:forwardChaining (a constant of type rif:IRI), for it accounts for a common conflict resolution strategy used in most forward-chaining production rule systems. That conflict resolution strategy selects a single rule instance for execution.

Future versions of the RIF-PRD specification may specify normatively the intended conflict resolution strategies to be attached to additional keywords. In addition, RIF-PRD documents may include non-standard keywords: it is the responsibility of the producers and consumers of such document to agree on the intended conflict resolution strategies that are denoted by such non-standard keywords. Future or non-standard conflict resolution strategies may select an ordered set of rule instances for execution, instead of a single one: the functions picked and actions, in the previous section, have been defined to take this case into account.

Conflict resolution strategy: rif:forwardChaining

Most existing production rule systems implement conflict resolution algorithms that are a combination of the following elements (under these or other, idiosyncratic names; and possibly combined with additional, idiosyncratic rules):

• Refraction. The essential idea of refraction is that a given instance of a rule must not be fired more than once as long as the reasons that made it eligible for firing hold. In other terms, if an instance has been fired in a given state of the system, it is no longer eligible for firing as long as it satisfies the states of facts associated to all the subsequent system states;
• Priority. The rule instances are ordered by priority of the instantiated rules, and only the rule instances with the highest priority are eligible for firing;
• Recency. the rule instances are ordered by the number of consecutive system states, or the number of consecutive cycles, in which they have been in the conflict set, and only the most recently fireable ones are eligible for firing. Note that the recency rule, used alone, results in depth-first processing.

Many existing production rule systems implement also some kind of fire the most specific rule first strategy, in combination with the above. However, whereas they agree on the definition of refraction and the priority or recency ordering, existing production rule systems vary widely on the precise definition of the specificity ordering. As a consequence, rule instance specificity was not included in the basic conflict resolution strategy that RIF-PRD specifies normatively.

The RIF-PRD keyword rif:forwardChaining denotes the common conflict resolution strategy that can be summarized as follows: given a conflict set

1. Refraction is applied to the conflict set, that is, all the refracted rule instances are removed from further consideration;
2. The remaining rule instances are ordered by decreasing priority, and only the rule instances with the highest priority are kept for further consideration;
3. The remaining rule instances are ordered by decreasing recency, and only the most recent rule instances are kept for further consideration;
4. Any remaining tie is broken is some way, and a single rule instance is kept for firing.

As specified earlier, picked(s) denotes the ordered list of the rule instances that were picked in a system state, s. Under the conflict resolution strategy denoted by rif:forwardChaining, for any given system state, s, the list denoted by picked(s) contains a single rule instance.

Given a system state, s, a rule set, RS, and a rule instance, ri ∈ conflictSet(RS, s), let recency(ri, s) denote the number of system states before s, in which ri has been continuously a matching instance: if s is the current system state, recency(ri, s) provides a measure of the recency of the rule instance ri. recency(ri, s) is specified recursively as follows:

• if previous(s) = NIL, then recency(ri, s) = 1;
• else if ri ∈ conflictSet(RS, previous(s)), then recency(ri, s) = 1 + recency(ri, previous(s));
• else, recency(ri, s) = 1.

In the same way, given a rule instance, ri, and a system state, s, let lastPicked(ri, s) denote the number of system states before s, since ri has been last fired. lastPicked(ri, s) is specified recursively as follows:

• if previous(s) = NIL, then lastPicked(ri, s) = 1;
• else if ri ∈ picked(previous(s)), then lastPicked(ri, s) = 1;
• else, lastPicked(ri, s) = 1 + lastPicked(ri, previous(s)).

Given a rule instance, ri, let priority(ri) denote the priority that is associated to rule(ri), or zero, if no priority is associated to rule(ri). If rule(ri) is inside nested Groups, priority(ri) denotes the priority that is associated with the innermost Group to which a priority is explicitly associated, or zero.

Example 4.3. Consider the following RIF-PRD document:

Document (
  Prefix( ex2 <http://example.com/2009/prd3#> )
  (* ex2:ExampleRuleSet *)
  Group (
    (* ex2:Rule_1 *) Forall ...
    (* ex2:HighPriorityRules *)
    Group 10 (
      (* ex2:Rule_2 *) Forall ...
      (* ex2:Rule_3 *) 
      Group 9 (Forall ... ) )
    (* ex2:NoPriorityRules *)
    Group (
      (* ex2:Rule_4 *) Forall ...
      (* ex2:Rule_5 *) Forall ... )
 )

Because the ex2:ExampleRuleSet group does not specify a priority, the default priority 0 is used. Rule 1, not being in any other group, inherits its priority, 0, from the top-level group.

Rule 2 inherits its priority, 10, from the enclosing group, identified as ex2:HighPriorityRules. Rule 3 specifies its own, lower, priority: 9.

Since neither Rule 4 nor Rule 5 specify a priority, they inherit their priority from the enclosing group ex2:NoPriorityRules, which does not specify one either, and, thus, they inherit 0 from the top-level group, ex2:ExampleRuleSet.   ☐

Given a set of rule instances, cs, the conflict resolution strategy rif:forwardChaining can now be described with the help of four rules, where ri and ri' are rule instances:

1. Refraction rule: if ri ∈ cs and lastPicked(ri, s) < recency(ri, s), then cs = cs - ri;
2. Priority rule: if ri ∈ cs and ri' ∈ cs and priority(ri) < priority(ri'), then cs = cs - ri;
3. Recency rule: if ri ∈ cs and ri' ∈ cs and recency(ri, s) > recency(ri', s), then cs = cs - ri;
4. Tie-break rule: if ri ∈ cs, then cs = {ri}. RIF-PRD does not specify the tie-break rule more precisely: how a single instance is selected from the remaining set is implementation specific.

The refraction rule removes the instances that have been in the conflict set in all the system states at least since they were last fired; the priority rule removes the instances such that there is at least one instance with a higher priority; the recency rule removes the instances such that there is at least one instance that is more recent; and the tie-break rule keeps one rule from the set.

To select the singleton rule instance, picked(s), to be fired in a system state, s, given a rule set, RS, the conflict resolution strategy denoted by the keyword rif:forwardChaining consists of the following sequence of steps:

1. initialize picked(s) with the conflict set, that a rule set RS determines in a system state s: picked(s) = conflictSet(RS, s);
2. apply the refraction rule to all the rule instances in picked(s);
3. then apply the priority rule to all the remaining instances in picked(s);
4. then apply the recency rule to all the remaining instances in picked(s);
5. then apply the tie-break rule to the remaing instance in picked(s);
6. return picked(s).

Example 4.4. Consider, from example 4.2, the conflict set that the rule set ex1:CheckoutRuleset determines in the system state, s₂, that corresponds to the state w₂ = facts(s₂) of the fact base, and use it to initialize the set of rule instance considered for firing, picked(s₂):

conflictSet(ex1:CheckoutRuleset, s₂) = { ex1:DiscountRule/{(_john/?customer)} } = picked(s₂)

The single rule instance in the conflict set, ri = ex1:DiscountRule/{(_john/?customer)}, did already belong to the conflict sets in the two previous states, conflictSet(ex1:CheckoutRuleset, s₁) and conflictSet(ex1:CheckoutRuleset, s₀); so that its recency in s₂ is: recency(ri, s₂) = 3.

On the other hand, that rule instance was fired in system state s₁: picked(s₁) = (ex1:DiscountRule/{(_john/?customer)}); so that, in s₂, it has been last fired one cycle before: lastPicked(ri, s₂) = 1.

Therefore, lastPicked(ri, s₂) < recency(ri, s₂), and ri is removed from picked(s₂) by refraction, leaving picked(s₂) empty.   ☐

RIF-PRD gives meaning to one-argument import directives only. Such directives can be used to import other RIF-PRD and RIF-Core documents. Two-argument import directives are provided to enable import of other types of documents, and their semantics is covered by other specifications. For example, the syntax and semantics of the import of RDF and OWL documents, and their combination with a RIF document, is specified in [RIF-RDF+OWL].

Definition (RIF-PRD document). A RIF-PRD document consists of zero or more import directives, and zero or one group.   ☐

Definition (Imported document). A document is said to be directly imported by a RIF document, D, if and only if it is identified by the locator IRI in an import directive in D. A document is said to be imported by a RIF document, D, if it is directly imported by D, or if it is imported, directly or not, by a RIF document that is directly imported by D.   ☐

The semantics of a well-formed RIF-PRD document that contains no import directive is the semantics of the rule set that is represented by the top-level group in the document, evaluated with the conflict resolution strategy that is associated to the document, and the default halting test, as specified above, in section Halting test.

The semantics of a well-formed RIF-PRD document, D, that imports the well-formed RIF-PRD documents D₁, ..., D_n, n ≥ 1, is the semantics of the rule set that is the union of the rule sets represented by the top-level groups in D and the imported documents, with the rif:local constants renamed to ensure that the same symbol does not occur in two different component rule sets, and evaluated with the conflict resolution strategy that is associated to the document, and the default halting test.

In addition to externally specified functions and predicates, and in particular, in addition to the functions and predicates built-ins defined in [RIF-DTB], RIF-PRD supports externally specified actions, and defines action built-ins.

The syntax and semantics of action built-ins are specified like for the other buit-ins, as described in the section Syntax and Semantics of Built-ins in [RIF-DTB]. However, their formal semantics is trivial: action built-ins behave like predicates that are always true, since action built-ins, in RIF-PRD, MUST NOT affect the semantics of the rules.

Although they must not affect the semantics of the rules, action built-ins may have other side effects.

RIF action built-ins are defined in the namespace: http://www.w3.org/2007/rif-builtin-action#. In this document, we will use the prefix: act: to denote the RIF action built-ins namespace.

Let Τ be a set of datatypes and symbol spaces that includes the datatypes specified in [RIF-DTB] and the symbol spaces rif:iri and rif:local. Suppose also that Ε is a set of external predicates and functions that includes the built-ins listed in [RIF-DTB] and in the section Built-in actions. We say that a rule r is a RIF-PRD_Τ,Ε rule if and only if

• r is a well-formed RIF-PRD rule,
• all the datatypes and symbol spaces used in r are in Τ, and
• all the externally defined functions and predicates used in r are in Ε.

Suppose, further, that C is a set of conflict resolution strategies that includes the one specified in section Conflict resolution, and that H is a set of halting tests that includes the one specified in section Halting test: we say that a rule set , R, is a RIF-PRD_Τ,Ε,C,H rule set if and only if

• R contains only RIF-PRD_Τ,Ε rules,
• the conflict resolution strategy that is associated to R is in C, and
• the halting test that is associated to R is in H.

Given a RIF-PRD_Τ,Ε,C,H rule set, R, an initial state of the fact base, w, a conflict resolution strategy c ∈ C and a halting test h ∈ H, let F_R,w,c,h denote the set of all the sets, f, of RIF-PRD ground atomic formulas that represent final states of the fact base, w' , according to the operational semantics of a RIF-PRD production rule system, that is: f ∈ F_R,w,c,h if and only if there is a state, s' , of the system, such that Eval(R, c, h, w) →^*_PRS s' and w' = facts(s') and f is a representation of w' .

In addition, given a rule language, L, a rule set expressed in L, R_L, a conflict resolution strategy, c, a halting test, h, and an initial state of the fact base, w, let F_{L,RL, c, h, w} denote the set of all the formulas in L that represent a final state of the fact base that an L processor can possibly reach.

Definition (Semantics preserving mapping).

• A mapping from a RIF-PRD_Τ,Ε,C,H, R, to a rule set, R_L, expressed in a language L, is semantics-preserving if and only if, for any initial state of the fact base, w, conflict resolution strategy, c, and halting test, h, it also maps each L formula in F_{L,RL, c, h, w} onto a set of RIF-PRD ground formulas in F_R,w,c,h;
• A mapping from a rule set, R_L, expressed in a language L, to a RIF-PRD_Τ,Ε,C,H, R, is semantics-preserving if an only if, for any initial state of the fact base, w, conflict resolution strategy, c, and halting test, h, it also maps each set of ground RIF-PRD atomic formulas in F_R,w,c,h onto an L formula in F_{L,RL, c, h, w}.   ☐

• A RIF processor is a conformant RIF-PRD_Τ,Ε,C,H consumer iff it implements a semantics-preserving mapping from the set of all safe RIF-PRD_Τ,Ε,C,H rule sets to the language L of the processor;
• A RIF processor is a conformant RIF-PRD_Τ,Ε,C,H producer iff it implements a semantics-preserving mapping from a subset of the language L of the processor to a set of safe RIF-PRD_Τ,Ε,C,H rule sets;
• An admissible document is an XML document that conforms to all the syntactic constraints of RIF-PRD, including ones that cannot be checked by an XML Schema validator;
• A conformant RIF-PRD consumer is a conformant RIF-PRD_Τ,Ε,C,H consumer in which Τ consists only of the symbol spaces and datatypes, Ε consists only of the externally defined functions and predicates, C consists only of the conflict resolution strategies, and H consists only of halting tests that are required by RIF-PRD. The required symbol spaces are rif:iri and rif:local, and the datatypes and externally defined terms (built-ins) are the ones specified in [RIF-DTB] and in the section Built-in actions. The required conflict resolution strategy is the one that is identified as rif:forwardChaining, as specified in section Conflict resolution; and the required halting test is the one specified in section Halting test. A conformant RIF-PRD consumer must reject all inputs that do not match the syntax of RIF-PRD. If it implements extensions, it may do so under user control -- having a "strict RIF-PRD" mode and a "run-with-extensions" mode;
• A conformant RIF-PRD producer is a conformant RIF-PRD_Τ,Ε,C,H producer which produces documents that include only the symbol spaces, datatypes, externals, conflict resolution strategies and halting tests that are required by RIF-PRD.   ☐

In addition, conformant RIF-PRD producers and consumers SHOULD preserve annotations.

[RIF-Core] is specified as a specialization of RIF-PRD: all valid [RIF-Core] documents are valid RIF-PRD documents and must be accepted by any conformant RIF-PRD consumer.

Conversely, it is desirable that any valid RIF-PRD document that uses only abstract syntax that is defined in [RIF-Core] be a valid [RIF-Core] document as well. For some abstract constructs that are defined in both RIF-Core and RIF-PRD, RIF-PRD defines alternative XML syntax that is not valid RIF-Core XML syntax. For example, an action block that contains no action variable declaration and only assert atomic actions can be expressed in RIF-PRD using the XML elements Do or And. Only the latter option is valid RIF-Core XML syntax.

To maximize interoperability with RIF-Core and its non-RIF-PRD extensions, a conformant RIF-PRD consumer SHOULD produce valid [RIF-Core] documents whenever possible. Specifically, a conformant RIF-PRD producer SHOULD use only valid [RIF-Core] XML syntax to serialize a rule set that satisfies all of the following:

• the conflict resolution strategy is effectively equivalent to the stratagy that RIF-PRD identifies by the IRI rif:forwardChaining,
• no condition formula contains a negation, in any rule in the rule set,
• no rule in the rule set has anaction block that contains a action variable declaration, and
• in all the rules in the rule set, the action block contains only assert atomic actions.

When processing a rule set that satisfies all the above conditions, a RIF-PRD producer is guaranteed to produce a valid [RIF-Core] XML document by applying the following rules recursively:

1. Remove redundant information. The behavior role element and all its sub-elements should be omitted in the RIF-PRD XML document;
2. Remove nested rule variable declarations. If the rule inside a rule with variable delcaration, r₁, is also a rule with variable declaration, r₂, all the rule variable delarations and all the binding patterns that occur in r₁ (and not in r₂) should be added to the rule variable declarations and the binding patterns that occur in r₂, and, after the transform, r₁ should be replaced by r₂, in the rule set;
3. Remove binding patterns. If a binding pattern occurs in a rule with variable declaration, r₁:
   • if the rule inside r₁ is a unconditional action block, r₂, r₂ should be transformed into a conditional action block, where the condition is the binding pattern, and the binding pattern should be removed from r₁,
   • if the rule inside r₁ is a conditional action block, r₂, the formula that represents the condition in r₂ should be replaced by the conjunction of that formula and the formula that represents the binding pattern, and the binding pattern should be removed from r₁;
4. Convert action blocks. The action block, in each rule, should be replaced by a conjunction, and, inside the conjunction, each assert action should be replaced by its target atomic formula.

Example 7.1. Consider the following rule, R, derived from the Gold rule, in the running example, to have only assertions in the action part:

R: Forall ?customer such that (And( ?customer # ex1:Customer
                                    ?customer[status->"Silver"] ) )
      (Forall ?shoppingCart such that (?customer[shoppingCart->?shoppingCart])
         (If Exists ?value (And( ?shoppingCart[value->?value]
                                 pred:numeric-greater-than-or-equal(?value 2000))
          Then Do( Assert(ex1:Foo(?customer))
                   Assert(ex1:Bar(?shoppingCart)) ) ) )

The serialization of R in the following RIF-Core conformant XML form does not impacts its semantics (see example 7.12 for another valid RIF-PRD XML serialization, that is not RIF-Core conformant):

<Forall>
   <declare><Var>?customer</Var></declare>
   <declare><Var>?shoppingCart</Var></declare>
   <formula>
      <Implies>
         <if>
            <And>
               <formula>   <!-- first pattern -->
                  <And>
                     <formula><Member> ... </Member></formula>
                     <formula><Frame> ... </Frame></formula>
                  </And>
               </formula>
               <formula>   <!-- second pattern -->
                  <Member> ... </Member>
               </formula>
               <formula>   <!-- original existential condition -->
                  ...
               </formula>
           </And>
        </if>
        <then>
           <And>
              <formula>   <!-- serialization of ex1:Foo(?customer) -->
                 ...
              </formula>
              <formula>   <!-- serialization of ex1:Bar(?shoppingCart) -->
                 ...
              </formula>
        </then>
     </Implies>
  </formula>
</Forall>

<!-- sample pseudo-schema -->
    <defined_element
          required_attribute_of_type_string="xs:string"
          optional_attribute_of_type_int="xs:int"? >
      <required_element />
      <optional_element />?
      <one_or_more_of_these_elements />+
      [ <choice_1 /> | <choice_2 /> ]*
    </defined_element>

    [ Const | Var | List | External ]

    <Const type=rif:iri [xml:lang=xsd:language]? >
        Any Unicode string
    </Const>

<Const type="xsd:integer">2000</Const>

<Const type="rif:iri">
   http://example.com/2009/prd2#Customer
</Const>

<Const type="xsd:int">123</Const>

    <Var> any Unicode string </Var>

    <List>
       GROUNDTERM*
    </List>

<List>
  <Const type="xsd:string> New </Const>
  <Const type="xsd:string> Bronze </Const>
  <Const type="xsd:string> Silver </Const>
  <Const type="xsd:string> Gold </Const>
</List>

    <External>
       <content>
          <Expr>
             <op> Const </op>
             <args rif:ordered="yes"> TERM+ </args>?
          </Expr>
       </content>
    </External>

<External>
   <content>
      <Expr>    
         <op> <Const type="rif:iri"> http://www.w3.org/2007/rif-builtin-function#numeric-amultiply </Const> </op>
         <args rif:ordered="yes"> 
            <Var> ?value </Var>
            <Const type="xsd:decimal"> 0.9 </Const>
         </args>
      </Expr>
   </content>
</External>

    [ Atom | Equal | Member | Subclass | Frame | External ]

    <Atom>
       <op> Const </op>
       <args ordered="yes"> TERM+ </args>?
    </Atom>

<Atom>
   <op>
      <Const type="rif:iri">
         http://example.com/2009/prd2#gold
      </Const>
   </op>
   <args ordered="yes">
      <Var> ?customer </Var>
   </args>
</Atom>

    <Equal>
       <left> TERM </left>
       <right> TERM </right>
    </Equal>

    <Member>
       <instance> TERM </instance>
       <class> TERM </class>
    </Member>

<Member>
   <instance> <Var> ?customer </Var> </instance>
   <class>
      <Const type="rif:iri">
         http://example.com/2009/prd2#Customer
      </Const>
   </class>
</Member>

    <Subclass>
       <sub> TERM </sub>
       <super> TERM </super>
    </Subclass>

    <Frame>
       <object> TERM </object>
       <slot rif:ordered="yes"> TERM TERM </slot>*
    </Frame>

<Frame>
   <object> <Var> ?customer </Var> </object>
   <slot rif:ordered="yes"> 
      <Const type="rif:iri">
         http://example.com/2009/prd2#status
      </Const>
      <Const type="xsd:string> Gold </Const>
   </slot>
</Frame>

    <External>
       <content>
          Atom
       </content>
    </External>

<External>
   <content>
      <Atom>    
         <op> <Const type="rif:iri"> http://www.w3.org/2007/rif-builtin-predicate#numeric-greater-than-or-equal </Const> </op>
         <args rif:ordered="yes">
            <Var> ?value </Var>
            <Const type="xsd:integer"> 2000 </Const>
         </args>
      </Atom>
   </content>
</External>

    [ ATOMIC | And | Or | INeg | Exists ]

    <And>
       <formula> FORMULA </formula>*
    </And>

    <Or>
       <formula> FORMULA </formula>*
    </Or>

    <INeg>
       <formula> FORMULA </formula>
    </INeg>

    <Exists>
       <declare> Var </declare>+
       <formula> FORMULA </formula>
    </Exists>

<Exists>
   <declare> <Var> ?value </Var> </declare>
   <formula>
      <And>
         <Frame>
            <object> <Var> ?shoppingCart </Var> </object>
            <slot rif:ordered="yes"> 
               <Const type="rif:iri">
                  http://example.com/2009/prd2#value
               </Const>
               <Var> ?value </Var>
            </slot>
         </Frame>
         <External>
            <content>
               <Atom>    
                  <op> <Const type="rif:iri"> http://www.w3.org/2007/rif-builtin-predicate#numeric-greater-than-or-equal </Const> </op>
                  <args rif:ordered="yes">
                     <Var> ?value </Var>
                     <Const type="xsd:integer"> 2000 </Const>
                  </args>
               </Atom>
            </content>
         </External>
      </And>
   </formula>
</Exists>

    [ Assert | Retract | Modify | Execute ]

    <Assert>
         <target> [ Atom | Frame | Member ] </target>
    </Assert>

    <Retract>
       <target> [ Atom | Frame | TERM ] </target>
    </Retract>

    <Modify>
         <target> Frame </target>
    </Modify>

<Modify>
   <target>
      <Frame>
         <object>
            <Var> ?customer </Var>
         </object>
         <slot rif:ordered="yes">
            <Const type="rif:iri"> http://example.com/2009/prd2#status </Const>
            <Const type="xsd:string"> Gold </Const>
         </slot>
      </Frame>
   </target>
</Modify>

    <Execute>
         <target> Atom </target>
    </Execute>

<Execute>
  <target>
    <Atom>
      <op>
        <Constant type="rif:iri"> http://www.w3.org/2007/rif-builtin-action#print </Const>
      </op>
      <args rif:ordered="yes">
        <External>
          <content>
            <Expr>
              <op>
                <Constant type="rif:iri"> http://www.w3.org/2007/rif-builtin-function#concat </Const>
              </op>
              <args rif:ordered="yes">
                <Const type="xsd:string> New customer: </Const>
                 ?customer 
              </args>
            </Expr>
          </content>
        </External>
      </args>
    </Atom>
  </target>
</Execute>

    [ Do | And | Atom | Frame ]

    <New />

    <Do>
       <actionVar rif:ordered="yes">
          Var
          [ New | Frame ]
       </actionVar>*
       <actions rif:ordered="yes">
          ATOMIC_ACTION+
       </actions>
    </Do>

<Do>
   <actionVar rif:ordered="yes">
      <Var>?voucher</Var>
      <New />
   </actionVar>
   <actions  rif:ordered="yes">
      <Assert>
         <target>
            <Member>
               <instance><Var>?voucher</Var></instance>
               <class>
                  <Const type="rif:iri">http://example.com/2009/prd2#Voucher</Const>
               </class>
            </Member>
         </target>
      </Assert>
      <Assert>
         <target>
            <Frame>
               <object><Var>?voucher</Var></object>
               <slot rif:ordered="yes">
                  <Const type="rif:iri">http://example.com/2009/prd2#value</Const>
                  <Const type="xsd:integer">5</Const>
               </slot>
            </Frame>
         </target>
      </Assert>
      <Assert>
         <target>
            <Frame>
               <object><Var>?customer</Var></object>
               <slot rif:ordered="yes">
                  <Const type="rif:iri">http://example.com/2009/prd2#voucher</Const>
                  <Var>?voucher</Var>
               </slot>
            </Frame>
         </target>
      </Assert>
   </actions>
</Do>

    [ Implies | Forall | ACTION_BLOCK ]

    <Implies>
       <if> FORMULA </if>
       <then> ACTION_BLOCK </then>
    </Implies>

    <Forall>
       <declare> Var </declare>+
       <pattern> FORMULA </pattern>*
       <formula> RULE </formula>
    </Forall>

<Forall>
   <declare><Var>?customer</Var></declare>
   <pattern>
      <And>
         <formula><Member> ... </Member></formula>
         <formula><Frame> ... </Frame></formula>
      </And>
   </pattern>
   <formula>
      <Forall>
         <declare><Var>?shoppingCart</Var></declare>
         <pattern><Member> ... </Member></pattern>
         <formula>
            <Implies> ... </Implies>
         </formula>
      </Forall>
   </formula>
</Forall>

    <Group>
       <behavior>
          <ConflictResolution> xsd:anyURI </ConflictResolution>?
          <Priority> -10,000 ≤ xsd:int ≤ 10,000 </Priority>?
       </behavior>?
       <sentence> [ RULE | Group ] </sentence>*
    </Group>

    <Import>
       <location> xsd:anyURI </location>
       <profile> xsd:anyURI </profile>?
    </Import>

    <Document>
       <directive> Import </Import>*
       <payload> Group </payload>?
    </Document>

    CLASSELT = [ TERM | ATOMIC | FORMULA | ATOMIC_ACTION | ACTION_BLOCK | New | RULE | Group | Document | Import ]

   <any concrete element in CLASSELT>
       <id> Const </id>?
       <meta>
          [ Frame 
            |
            <And>
               <formula> Frame </formula>*
            </And>
          ]
       </meta>?
       other CLASSELT content
    </any concrete element in CLASSELT>

<Document>
  <payload>
    <Group>
      <id><Const type="rif:iri">http://example.com/2009/prd2#CheckoutRuleSet</Const></id>
      <meta>
        <Frame>
          <object><Const type="rif:iri">http://example.com/2009/prd2#CheckoutRuleSet</Const></object>
          <slot rif:ordered="yes">
            <Const type="rif:iri">http://dublincore.org/documents/dcmi-namespace/creator</Const>
            <Const type="xsd:string>W3C RIF WG</Const>
          </slot>
          <slot>
            <Const type="rif:iri">http://dublincore.org/documents/dcmi-namespace/description</Const>
            <Const type="xsd:string">Running example rule set from the RIF-PRD specification</Const>
          </slot>
        </Frame>
      </meta>
      <behavior> ... </behavior>
      <sentence>
        <Group>
          <id><Const type="rif:iri">http://example.com/2009/prd2#GoldRule</Const></id>
          <behavior> ... </behavior>
          <sentence><Forall> ... </Forall></sentence>
        </Group>
      </sentence>
      <sentence>
        <Group>
          <id><Const type="rif:iri">http://example.com/2009/prd2#DiscountRule</Const></id>
          <sentence><Forall> ... </Forall></sentence>
        </Group>
      </sentence>
    </Group>
  </payload>
</Document>

  Document       ::= IRIMETA? 'Document' '(' Base? Prefix* Import* Group? ')'
  Base           ::= 'Base' '(' ANGLEBRACKIRI ')'
  Prefix         ::= 'Prefix' '(' Name ANGLEBRACKIRI ')'
  Import         ::= IRIMETA? 'Import' '(' LOCATOR PROFILE? ')'
  Group          ::= IRIMETA? 'Group' Strategy? Priority? '(' (RULE | Group)* ')'
  Strategy       ::= Const
  Priority       ::= Const
  RULE           ::= (IRIMETA? 'Forall' Var+ ' such that ' FORMULA*  '(' RULE ')') | CLAUSE
  CLAUSE         ::= Implies | ACTION_BLOCK 
  Implies        ::= IRIMETA? 'If' FORMULA 'Then' ACTION_BLOCK
  LOCATOR        ::= ANGLEBRACKIRI
  PROFILE        ::= ANGLEBRACKIRI

  ATOMIC_ACTION  ::= IRIMETA? (Assert | Retract | Modify | Execute )
  Assert         ::= 'Assert' '(' Atom | Frame | Member ')'
  Retract        ::= 'Retract' '(' ( Atom | Frame | Var | Const ) ')'
  Modify         ::= 'Modify'  '(' Frame ')'
  Execute        ::= 'Execute' '(' Atom ')' 
  ACTION_BLOCK   ::= IRIMETA? ('Do (' (IRIMETA? Var (Frame | 'New()'))* ATOMIC_ACTION+  ')' |
                     'And (' (Atom | Frame)* ')' | Atom | Frame)

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

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

Document(

 Prefix( ex1 <http://example.com/2009/prd2> )

 (* ex1:CheckoutRuleset *)
 Group rif:forwardChaining (  
   (* ex1:GoldRule *)
   Group 10 (
     Forall ?customer such that (And( ?customer # ex1:Customer
                                      ?customer[status->"Silver"] )) 
       (Forall ?shoppingCart such that (?customer[shoppingCart->?shoppingCart])
          (If Exists ?value (And( ?shoppingCart[value->?value]
                                  pred:numeric-greater-than-or-equal(?value 2000))
           Then Do( Modify( ?customer[status->"Gold"] ) ) ) ) ) )

   (* ex1:DiscountRule *)
   Group (
     Forall ?customer such that (And( ?customer # ex1:Customer ) )
       (If Or( ?customer[status->"Silver"]
               ?customer[status->"Gold"] )
        Then Do( (?s ?customer[shoppingCart->?s])
                 (?v ?s[value->?v])
                 Modify( ?s[value->func:numeric-multiply(?v 0.95)] ) ) ) )

   (* ex1:NewCustomerAndWidgetRule *)
   Group
     Forall ?customer such that (And( ?customer # ex1:Customer
                                      ?customer[status->"New"] ) )
       (If Exists ?shoppingCart ?item
                  ( And ( ?customer[shoppingCart->?shoppingCart]
                          ?shoppingCart[containsItem->?item]
                          ?item # ex1:Widget ) ) )
        Then Do( (?s ?customer[shoppingCart->?s])
                 (?val ?s[value->?val])
                 (?voucher ?customer[voucher->?voucher])
                 Retract( ?customer[voucher->?voucher] )
                 Retract( ?voucher )
                 Modify( ?s[value->func:numeric-multiply(?val 0.90)] ) ) ) )

   (* ex1:UnknownStatusRule *)
   Group (
     Forall ?customer such that ( ?customer # ex1:Customer )
       (If Not(Exists ?status
                      (And( ?customer[status->?status]
                            External(pred:list-contains(List("New", "Bronze", "Silver", "Gold"), ?status)) )))
        Then Do( Execute( act:print(func:concat("New customer: " ?customer)) )
                 Assert( ?customer[status->"New"] ) ) ) ) )
)   ☐

<?xml version="1.0" encoding="UTF-8"?>
 
<xs:schema
    targetNamespace="http://www.w3.org/2007/rif#"
    xmlns:xs="http://www.w3.org/2001/XMLSchema"
    xmlns="http://www.w3.org/2007/rif#"
    elementFormDefault="qualified">
 
<!-- ================================================== -->
<!-- RIF PRD Rule Language                            -->
<!-- ================================================== -->

<!-- Redefine some elements in the Core rule language   -->

<xs:redefine schemaLocation="CoreRule.xsd">

  <!-- Group          ::= IRIMETA? 'Group' Name? '(' (RULE | Group)* ')' -->
 <xs:group name="Group.content">
      <xs:sequence>
        <xs:group ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
        <!-- Adds behavior to Group -->
        <xs:element ref="behavior" minOccurs="0" maxOccurs="1"/>
        <xs:element ref="sentence" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
 </xs:group>

 <!-- RULE           ::= (IRIMETA? 'Forall' Var+ ' such that ' FORMULA*  '(' RULE ')') | CLAUSE -->
  <xs:group name="Forall.content">
      <xs:sequence>
        <xs:group ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
        <xs:element ref="declare" minOccurs="1" maxOccurs="unbounded"/>
        <!-- Adds pattern to Forall -->
        <xs:element ref="pattern" minOccurs="1" maxOccurs="unbounded"/>
        <!-- different from formula in And, Or and Exists -->
        <xs:element name="formula">
          <xs:complexType>
            <xs:group ref="CLAUSE"/>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
  </xs:group>

  <!-- Implies        ::= IRIMETA? 'If' FORMULA 'Then' ACTION_BLOCK  -->
  <xs:group name="then.content">
     <xs:choice>
       <xs:group ref="ACTION_BLOCK"/>
     </xs:choice>
  </xs:group>


</xs:redefine>

<!-- ================================================== -->
<!-- RIF PRD Condition Language                         -->
<!-- ================================================== -->

<!-- Redefine some elements in the Core Conditions      -->

<xs:redefine schemaLocation="CoreCond.xsd">


   <!-- FORMULA        ::= IRIMETA? 'And' '(' FORMULA* ')' |
                     IRIMETA? 'Or' '(' FORMULA* ')' |
                     IRIMETA? 'Exists' Var+ '(' FORMULA ')' |
                     ATOMIC |
                     IRIMETA? NEGATEDFORMULA  |
                     IRIMETA? Equal |
                     IRIMETA? Member |
                     IRIMETA? Subclass |
                     IRIMETA? 'External' '(' Atom ')' -->
   <xs:group name="FORMULA">
      <xs:choice>
         <xs:group ref="FORMULA"/>
         <xs:group ref="NEGATEDFORMULA"/>
         <xs:element ref="Subclass"/>
      </xs:choice>
   </xs:group>

</xs:redefine>


<!-- Additional elements to the Core Condition schema             -->
   
   <!-- Subclass         ::= TERM '##' TERM -->
   <xs:element name="Subclass">
      <xs:complexType>
         <xs:sequence>
            <xs:element name="sub">
               <xs:complexType>
                  <xs:group ref="TERM" minOccurs="1" maxOccurs="1"/>
               </xs:complexType>
            </xs:element>
            <xs:element name="super">
               <xs:complexType>
                  <xs:group ref="TERM" minOccurs="1" maxOccurs="1"/>
               </xs:complexType>
            </xs:element>
         </xs:sequence>
      </xs:complexType>
   </xs:element>

  <!--  NEGATEDFORMULA        ::= 'Not' '(' FORMULA ')' | 'INeg' '(' FORMULA ')'  
  ('INeg' should always be preferred to 'Not' is   there is the risk of an ambiguity with regards to the semantics of the negation) -->

  <xs:group name="NEGATEDFORMULA">
    <!--
      NEGATEDFORMULA        ::= 'INeg' '(' FORMULA ')' 
    -->
    <xs:sequence>
      <xs:element ref="INeg"/>
    </xs:sequence>
  </xs:group>
  
  <!-- 'INeg' '(' FORMULA ')'-->
  <xs:element name="INeg">
      <xs:complexType>
        <xs:sequence>
          <xs:group ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
          <xs:element ref="formula" minOccurs="0" maxOccurs="1"/>
        </xs:sequence>
      </xs:complexType>
   </xs:element>



<!-- Additional elements to the Core rule schema             -->

   <xs:element name="behavior">
      <xs:complexType>
         <xs:sequence>
            <xs:element name="ConflictResolution" minOccurs="0" maxOccurs="1" type="xs:anyURI"/>
            <xs:element name="Priority" minOccurs="0" maxOccurs="1" type="xs:int"/>
         </xs:sequence>
      </xs:complexType>
   </xs:element>


  <xs:element name="pattern">
                  <xs:complexType>
                     <xs:sequence>
                        <xs:group ref="FORMULA"/>
                     </xs:sequence>
                  </xs:complexType>
  </xs:element>



<!-- ================================================== -->
<!-- RIF PRD Action Language                            -->
<!-- ================================================== -->

  <!-- ACTION_BLOCK   ::= IRIMETA? ('Do (' (Var (Frame | 'New'))* ATOMIC_ACTION+  ')' |
                     'And (' (Atom | Frame)* ')' | Atom | Frame) -->

  <xs:group name="ACTION_BLOCK">
    <xs:sequence>
      <xs:group ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
      <xs:choice>
         <xs:element ref="Do"/>
         <xs:element ref="And"/>
         <xs:element ref="Atom"/>
         <xs:element ref="Frame"/>
      </xs:choice>
    </xs:sequence>
   </xs:group>

   <!-- 'Do (' (IRIMETA? Var (Frame | 'New'))* ATOMIC_ACTION+  ')' -->
   <xs:element name="Do">
      <xs:complexType>
         <xs:sequence>            
           <xs:element ref="actionVar" minOccurs="0" maxOccurs="unbounded"/>
           <xs:element ref="actions" minOccurs="1" maxOccurs="1"/>
         </xs:sequence>
      </xs:complexType>
   </xs:element>

   <xs:element name="actionVar">
         <xs:complexType>
               <xs:sequence>
                   <xs:group ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
                   <xs:element name="Var" minOccurs="1" maxOccurs="1"/>
                   <xs:element name="ACTIONVARIABLEDECLARATION" minOccurs="1" maxOccurs="1"/>
                </xs:sequence>
                <xs:attribute name="ordered" type="xs:string" fixed="yes"/>
          </xs:complexType>
   </xs:element>

   <xs:element name="actions">
               <xs:complexType>
                  <xs:sequence>
                     <xs:group ref="ATOMIC_ACTION" minOccurs="1" maxOccurs="unbounded"/>
                  </xs:sequence>
                  <xs:attribute name="ordered" type="xs:string" fixed="yes"/>
               </xs:complexType>
   </xs:element>

  <!-- The New element is always empty. -->
  <xs:element name="New">
  </xs:element>
   
   <xs:group name="ACTIONVARIABLEDECLARATION">
      <xs:choice>
         <xs:element ref="New"/>
         <xs:element ref="Frame"/>
      </xs:choice>
   </xs:group>

   <!-- ATOMIC_ACTION  ::= IRIMETA? (Assert | Retract | Modify | Execute ) -->
   <xs:group name="ATOMIC_ACTION">
    <xs:sequence>
      <xs:group ref="IRIMETA" minOccurs="0" maxOccurs="1"/>
      <xs:choice>
         <xs:element ref="Assert"/>
         <xs:element ref="Retract"/>
         <xs:element ref="Modify"/>
         <xs:element ref="Execute"/>
      </xs:choice>
    </xs:sequence>
   </xs:group>

   <!-- Assert         ::= 'Assert' '(' Atom | Frame | Member ')'-->
   <xs:element name="Assert">
      <xs:complexType>
         <xs:choice>
            <xs:element name="target" minOccurs="1" maxOccurs="1">
               <xs:complexType>
                  <xs:choice>
                     <xs:element ref="Atom"/>
                     <xs:element ref="Frame"/>
                     <xs:element ref="Member"/>
                  </xs:choice>
               </xs:complexType>
	    </xs:element>
	 </xs:choice>
     </xs:complexType>
   </xs:element>

   <!-- Retract        ::= 'Retract' '(' ( Atom | Frame | Var | Const ) ')'-->
   <xs:element name="Retract">
      <xs:complexType>
         <xs:choice>
            <xs:element name="target" minOccurs="1" maxOccurs="1">
               <xs:complexType>
                  <xs:choice>
                     <xs:element ref="Atom"/>
                     <xs:element ref="Frame"/>
                     <xs:group ref="TERM"/>
                  </xs:choice>
               </xs:complexType>
            </xs:element>
         </xs:choice>
      </xs:complexType>
   </xs:element>

   <!-- Modify         ::= 'Modify'  '(' Frame ')'-->
   <xs:element name="Modify">
      <xs:complexType>
         <xs:sequence>
            <xs:element name="target" minOccurs="1" maxOccurs="1">
               <xs:complexType>
                  <xs:choice>
                     <xs:element ref="Frame"/>
                  </xs:choice>
               </xs:complexType>
	    </xs:element>
	 </xs:sequence>
      </xs:complexType>
   </xs:element>

   <!-- Execute         ::= 'Execute'  '(' Atom ')'-->
   <xs:element name="Execute">
      <xs:complexType>
         <xs:sequence>
            <xs:element name="target" minOccurs="1" maxOccurs="1">
               <xs:complexType>
                  <xs:choice>
                     <xs:element ref="Atom"/>
                  </xs:choice>
               </xs:complexType>
	    </xs:element>
	 </xs:sequence>
      </xs:complexType>
   </xs:element>

  
 </xs:schema>

<Document>
  <payload>
    <Group>
      <id><Const type="rif:iri">http://example.com/2009/prd2#CheckoutRuleSet</Const></id>
      <meta>
        <Frame>
          <object><Const type="rif:iri">http://example.com/2009/prd2#CheckoutRuleSet</Const></object>
          <slot rif:ordered="yes">
            <Const type="rif:iri">http://dublincore.org/documents/dcmi-namespace/creator</Const>
            <Const type="xsd:string>W3C RIF WG</Const>
          </slot>
          <slot>
            <Const type="rif:iri">http://dublincore.org/documents/dcmi-namespace/description</Const>
            <Const type="xsd:string">Running example rule set from the RIF-PRD specification</Const>
          </slot>
        </Frame>
      </meta>
      <behavior>
        <ConflictResolution>rif:forwardChaining</ConflictResolution>
      </behavior>
      <sentence>
        <Group>
          <id><Const type="rif:iri">http://example.com/2009/prd2#GoldRule</Const></id>
          <behavior>
            <Priority> 10 </Priority>
          </behavior>
          <sentence><Forall> ... </Forall></sentence>
        </Group>
      </sentence>
      <sentence>
        <Group>
          <id><Const type="rif:iri">http://example.com/2009/prd2#DiscountRule</Const></id>
          <sentence><Forall> ... </Forall></sentence>
        </Group>
      </sentence>
    </Group>
  </payload>
</Document>