Method and system for capturing streaming data by an actionable information engine

[0002] This Application claims priority from U.S. Provisional Application No. 60/246,925, filed Nov. 9, 2000, the entire disclosure of which is hereby incorporated by reference.

[0003] The present invention relates generally to information analysis systems and methods, and more particularly to methods and systems for processing and analyzing streaming data.

[0004] In a system that encounters streaming data that has to be acted upon over time, the data is typically stored in the order in which it first arrived and then processed again and again over time as more data enters the system. The problem is that each time processing occurs, the data must be retrieved and rehandled, causing processing to get slower as the system acquires more and more data. It is an object of the present invention to address this shortcoming by providing a method and system that captures streaming data and avoids continual retrieval and rehandling. It is a further object of the present invention to provide a method and system which, in some cases, can become faster as the system acquires more data.

[0005] Briefly described, an information analysis system for processing and analyzing streaming data includes an engine processor having a plurality of inputs, a plurality of separate outputs, and a plurality of separate bi-directional input/output terminals. The engine processor is operative to process data according to stored information. A rules storage module is coupled to one input of said engine processor and operative to store a set of stored rules in defining engine operation. An input events module is coupled to another input of said engine processor and operative for receiving events and for providing a plurality of events from at least one received event, wherein the engine processes the events according to the stored rules for generating at a first output a series of valid results when predetermined input events occur according to the rules as processed by the engine. A first state storage unit is coupled to a bi-directional input/output terminal of the engine and is operative to store a state of a rule that the engine has matched to an input event but which has not yet produced a valid result, where the state of a rule is stored enabling the engine to provide a valid result output upon a future reception of an input event necessary to complete the rule. A transaction log module is coupled to an output of the engine and is operative to monitor the operation of the engine for specified time period necessary to complete partially satisfied rules.

[0006] The invention also includes a method for automatically triggering output events based upon a plurality of input events and a plurality of rules, wherein each of the rules can have a partially satisfied state. The method includes receiving at least one input event; restoring at least one state associated with the input event, the state indicative of ones of the rules having a partially satisfied state; applying the rules to the input event in light of the restored state to determine if any of the rules is fully satisfied, and if so triggering an output event based upon the fully satisfied rules; and, storing an updated state dependently the at least one other event.

[0007] Various other objects, features and advantages of the invention will become more apparent by reading the following detailed description in conjunction with the drawings, which are shown by way of example only, wherein:

[0008] FIG. 1 illustrates a block diagram of a system 10 according to one aspect of the present invention;

[0009] FIG. 2 illustrates a block diagram of the functional elements of the engine 40 according to another aspect of the present invention;

[0010] FIG. 3 illustrates a simple event rule utilized by the engine of the present invention;

[0011] FIG. 4 illustrates a pattern rule utilized by the engine of the present invention;

[0012] FIG. 5 illustrates the behavior detector of the present invention;

[0013] FIG. 6 illustrates the operation of the Rule State Section with the working rule state and the Event State Section with the working event state; and

[0014] FIGS. 7aand 7bfurther illustrate the operation illustrated in FIG. 6.

[0015] FIG. 8 illustrates a multiplied instance of the rule mechanism.

[0016] The present invention has applicability in: Real-Time Applications such as Personalization across all customer touch points and form factors—Web, Call Centers, POS, and TV, for example, Network control within routers, network elements, call agents, and gatekeepers, and ERP optimization, including inventory control. It is also well suited for use in High-throughput decision-making systems such as eCRM systems for enterprises of all sizes and operations support systems.

[0017] According to a preferred embodiment of the method and system of the invention, each piece of data is fed into all the rules, until no more data exists, unlike a traditional rule-based expert system, which tries to fire each rule in turn until it cycles through all the rules without a firing. The present invention makes this possible because the system has a time dependency built into it, and data that is not consumed at the moment at which it enters the system does not become useful at a later time, and is discarded. As understood by those possessing an ordinary level of skill in the art, a typical expert system does not have this inherent sense of time and assumes a timeless truth to all data at its disposal, and can go into an infinite loop if it were set to operate until all of its data is consumed.

[0018] Referring now to the Figures, like reference numbers identify like elements of the invention. FIG. 1 illustrates a block diagram of a system 10 according to a preferred embodiment of the present invention. The system 10 is a rule-based mechanism that holds on to relevant information that passes into it and draws inferences based on that information. Rules 20 are a set of rules that the engine 40 works on and include simple events rules 20a, pattern rules 20band alert rules 20cas will be discussed. Input events 30 are a set of time-dependent events that trigger activity within the engine 40. Engine 40 is a mechanism that reads input events 30, matches the input events 30 with the rules 20, and carries out actions in response thereto. The engine 40 generates results or alerts 50 that can be further fed into the engine 40. Results 50 are the output of the engine 40 firing a rule 20. State 60 is the state of a rule 20 held within a binary buffer that has matched on some input event 30 but has not yet fired to produce a result 50. Static Data storage device 70 stores further data that the engine 40 utilizes during its activities. Static data stored in device 70 is data that has been set by an entity outside the engine 40. For example, static data includes demographic information about customers, which can be utilized in implementing the rules as will be discussed. Transaction Log 80 provides an account of engine behavior.

[0019] There three types of rules 20: 1) Simple event rules 20a, which act upon transactions and information in the static database and generate symbols; 2) Pattern or behavior rules 20b, which act upon symbols and generate more symbols; and 3) Alert rules 20c, which act upon symbols and information in the static database and generate alerts.

[0020] A simple event rule 20aconsists of a set of preconditions on a single transaction (raw event) and a symbol. The set of preconditions consists of a Boolean expression on values in the transaction and values in the static database for the originator of the transaction. When a simple event rule 20agenerates a symbol, it is said to “fire.” Referring to FIG. 3, an example of a simple event rule 20ais, “If the activity is a stock trade and the amount transacted was 25% higher than the typical trade, then generate a simple event of type Increase-in-trading-activity.” The amount of a typical trade is an item stored within the static data 70. As an alternative example, the simple event rule “If (Transaction field A=20) AND (Age>25)→B” means, if field A in the transaction contains the value “20” and the age of the customer is greater than 25, then generate symbol B. Simple event rules 20aalways act upon one and only one transaction.

[0021] Pattern rules 20bhave the form: preconditions symbol, where the preconditions are a set of symbols, which, upon acquiring a set of symbols, generates another symbol. In order for a pattern rule 20bto satisfy its preconditions, a rule must be armed with a set of symbols under a set of arming constraints. These constraints generally take the form of this symbol has to be acquired first, or this symbol has to be acquired within a time constraint, or this symbol has to be acquired without getting another kind of symbol, or, any one of a set of symbols has to be acquired, for example. When a rule 20bgenerates a symbol, it is said to “fire.” For example, the pattern rule A & B→C means, if symbols A and B are available, then generate symbol C, as further illustrated in FIG. 4. A pattern rule is said to be in a partial state when part of the precondition is satisfied. With the present invention, a rule 20bwith partial state is stored in state 60 for a selected period of time, thus advantageously precluding the need to rerun the rules 20bas new data enters the system.

[0022] An alert rule, 20c, consists of a single symbol and a set of conditions on the fields in the static database for the individual for whom the rule pertains. When the conditions are met, the alert rule generates, or “triggers,” the alert. The alert can simply be thought of as a particular string directed at a particular customer. The following is an example of an alert rule: If the symbol “major withdrawal” is received, and the customer lives in New Jersey, then generate the alert “Call customer with low interest loan information.” In this case, the symbol is “major withdrawal,” and the conditions that must be met within the static database for this customer are: “the customer must live in New Jersey.” The alert can take many forms: in its simplest form it could be the string “Call particular customer with low interest loan information” written to a file or database, in its more complex form, it could be a directive delivered to the screen of a call center agent giving the name and telephone number of the particular customer and the message that the agent should present to the particular customer particular information about low interest loans. The delivery mechanism of the alert can take many forms.

[0023] The engine 40 processes input events 30 from a variety of data sources, including live streams, databases, and other information engines. According to one aspect of the present invention, the format of the data is not critical as data adapters can be used to transform any input into a form that can be processed by the simple event detector 20a. Typically, incoming data includes the following fields: user—describes who carried out the event; action—describes the nature of the event; date—marks the date and time that the event occurred; and, details—gives specific information about the event, for example, where it occurred. It is to be understood that the term “user” can refer to a particular person, an entity, or class of individuals.

[0024] In general, the activity of the engine 40 is one of detecting information. Conceptually, the system 10 is programmed by first specifying the required results 50 and then building the rule 20 infrastructure to capture the required information. The results 50 of the engine 40 are those input events that match at least one simple event rule, 20a, which is fired by the engine 40, and one alert rule, 20c, which is fired by the engine 40. The results 50 can be used in a variety of ways. For example, they can be viewed with a reporting capability that would state that a certain percentage of customers exhibited this behavior, and another percentage of customers exhibited another behavior. For example, there may be a unit that sends mail messages to customers who exhibit certain behaviors. Also, they can be used as input to other downstream processing activities as will be described.

[0025] Referring now to FIG. 2, a block diagram of the functional elements of the engine 40 according to a preferred embodiment of the present invention is illustrated. Generally, the engine 40 includes a simple events detector 42 for receiving input events 30 and implementing rules 20a, a trend detector 46 for querying the static data 70, a behavior detector 44 for receiving actions from simple event detector 42 and from trend detector 46 and for implementing rules 20, and an alert generator 48 for receiving symbols from simple event detector 42, behavior detector 44, and trend detector 46, and triggering or providing results 50.

[0026] Within the simple event detector 42, the initial raw input events 30 that enter the system pass through a set of simple event generation rules 20aand are transformed into simple events 32. The simple events detector 42 serves to simplify the bulk of the transactional information by removing information that is not relevant to the downstream processes. For example, if a piece of incoming information is only important if it refers to a person from a particular location, by utilizing an appropriate one of the rules 20a, the simple events detector 42 can disregard all incoming information when it does not originate from that location. A single raw event may match various rules 20aand generate several simple events. For example, the same transaction that triggered the simple event “Increase-in-trading-activity” might also trigger another simple event “Trade occurred.”

[0027] The simple events detector 42 serves to map the incoming information into a consistent form, so that multiple incoming information streams can be referenced in a single fashion. The simple events detector 42 also gives the incoming information a context of known information about the individual, so that this known information does not have to be continually identified. For example, if a piece of incoming information is important only if it refers to a person who is a “high-valued customer,” then the simple events detector 42 can make that distinction using an appropriate one of the rules 20a, which will check the static database of individual information for that value. Finally, the simple events detector 42 puts the incoming information into a simpler form that is more easily manipulated by the history-sensitive behavior detector 44.

[0028] A simple event contains a symbol fired by a simple event rule 20aand other details of the firing so that the entire activity can be logged unambiguously in the Transaction Log 80. A simple event 32 is a match defined by some rule R, on a transaction X, generating a symbol S, by the simple event detector 42. According to one aspect of the present invention, each simple event is unambiguously defined by the 5-tuple (C, S, (X), R, T), where: C is the customer id; S is the name of the symbol that the simple event rule 20agenerated; X is the location of the originating event; R is the particular simple event rule that created the symbol; and, T is a timestamp indicative of when symbol S was generated. A simple event 32 contains a symbol that is obtained from a rule 20athat fired. The symbol is used to match against patterns within downstream pattern rules 20b. Whenever an input event 30 is transformed into a simple event 32, the originating event 30 is logged into an addressable location in the transaction log 80. This location is recorded as the third value of the simple event.

[0029] The rule 20athat fired and generated a symbol has an identification (ID) that is recorded in the simple event. The rule id is recorded in order to disambiguate simple events that originate from the same raw event and generate the same symbol according to another aspect of the invention, since a single transaction can generate multiple simple events.

[0030] In a more detailed example, an incoming transaction record is an example of an input event 30 and a sequence of attribute value pairs. Transaction records are supplied as input events 30 from existing systems and can be provided in a streaming or even batch manner. For example, among other things, the attributes may contain a transaction owner identifier such as a customer id, as well as an activity, date, and details of the activity. As another example, if the present invention is used to characterize the behavior of packets moving through a router, then the transaction owner may be a “source ip address.” An example of a typical transaction record is:

[0031] <TRANSACTION>

[0032] <CUSTOMER_ID>1234</CUSTOMER_ID>

[0033] <ACTIVITY>withdraw</ACTIVITY>

[0034] <DATE>06/20/2000</DATE>

[0035] <DETAILS>

[0036] <AMOUNT>$100</AMOUNT>

[0037] <LOCATION>Bank 234, Princeton, N.J.</LOCATION>

[0038] </DETAILS>

[0039] </TRANSACTION>

[0040] In this case, the content of the record indicates that customer number 1234 withdrew $100 from Bank 234 in Princeton, N.J. on Jun. 20, 2000. In this case, the format used to convey the transaction record is eXtensible Markup Language (XML), but can be any other tag/value format, or otherwise suitable format. For example, a format where the fields are in fixed fields, either delimited by fixed lengths or separator characters, can be used.

[0041] An example of a simple event for the above-identified exemplary transaction would be to generate a Major-withdrawal symbol if more than $10,000 is withdrawn. A rule to implement this simple event is

[0042] Rule 1093: If activity=withdraw AND amount>$10000, then generate symbol Major-Withdrawal.

[0043] As set forth, transactions are logged in the transaction log 80, in this case in a transaction table named transtable for example. Supposing that the incoming transaction had been logged at transtable row 83822, and that the transaction is processed on Jun. 20, 2000 at 8:57PM, Rule 1093 fires and generates the symbol Major-Withdrawal, and logs the transaction in transtable at a row 83979, then the following simple event action will be generated and logged in transtable row 83979:

[0044] (1234, Major-Withdrawal, (transtable:83822), 1093, Jun. 20, 2000120:57).

[0045] Within the system 10, any future reference to this simple event is through its location in the transaction log, i.e., transtable:83979, according to another aspect of the present invention.

[0046] Still referring to FIG. 2, the behavior detector 44 tracks patterns of simple events, in the context of time, and outputs compound events. A compound event is a match, defined by some pattern rule R, on a combination of events C, generating a symbol S. According to an aspect of the present invention, each compound event is uniquely defined by the 5-tuple (C, S, (X), R, T), where: C is the customer id; S is the name of the symbol; X is the set of locations indicating all the events that matched against the rule (R) and caused it to fire; R is the rule that caught the combination and created the symbol; and, T is the timestamp when the rule was fired. Examples of the types of patterns that the behavior detector 44 seeks are: a sequence of events; a collection of events (a Boolean AND relationship); and, some events among many (a Boolean OR relationship). The behavior detector 44 also tracks patterns of compound events or trend events. It can discharge a state of a partially satisfied rule upon the receipt of either certain events or the expiration of a selected time period. The behavior detector 44 holds an account state for each customer, which it maintains over a selected period of time, and restores whenever a customer returns to generate more events, according to an aspect of the present invention. The engine 40 manages this account state using the state database 60.

[0047] Some examples illustrating typical functionalities of the behavior detector 44 include: detecting three Decrease_Trade events within a window of one week and triggering a Trade_Tending_to_Decrease compound event; detecting either a Trade_Tending to_Decrease” behavior or a Massive_Drop_in_Assets trend and triggering a Customer_likely_to_discontinue_doing_business symbol in response thereto; and, detecting that an account has seen no activity over a three-month period and firing a Three_Month_Inactivity symbol in response thereto.

[0048] Suppose the simple event detector generates the symbol “Major_Withdrawal” when a bank customer withdraws more than $10,000. Then an example of a compound event would capture the “Major_Withdrawal” symbol and wait for 5 weeks of inactivity, and then fire the symbol “Likely_to_Stop_Doing_Business.” A pattern rule to implement this is illustrated as an example:

[0049] Rule 4981: If Major_Withdrawal AND 5_Weeks_of_Inactivity, then Generate Symbol Likely_to_Stop_Doing_Business.

[0050] Suppose that the events Major_Withdrawal (transtable:83979) and 5_Weeks_of_Inactivity (transtable:91357) have fired as of the date Jul. 25, 2000 at 8:57PM. Intuitively this is saying that, the major_withdrawal event symbol fired by the simple event rule, and that 5 weeks later the inactivity event symbol fired. Suppose that the transaction is processed on Jul. 25, 2000 at 9:30PM, Pattern Rule 4981 fires, generates the symbol Likely_to_Stop_Doing_Business, it would log the following event at transtable: 91426 for example:

[0051] (1234, Likely to Stop Doing Business, transtable:83979, transtable:91357), 4981, Jul. 25, 2000|21:30).

[0052] The trend detector 46 identifies trends in the static data 70. It detects increase, decrease, and change trends for example. Some examples illustrating typical functionalities of the trend detector 46 include: detecting that assets have grown over a three-month period and triggering an Asset Growing trend symbol; and, detecting that a customer has changed his typical method of payment from checking to online and triggering a Payment_Method_Change trend symbol. Otherwise the operation of the trend detector 46 is analogous to that of the simple events detector 42.

[0053] The Alert Generator 48 evaluates event or action stimulus in the context of historical customer data and outputs alerts 50. According to one aspect of the present invention, a standard action is to filter the stimulus and record all triggered events within a trigger collection table. Static data is reevaluated at the time the alert is triggered.

[0054] According to another aspect of the invention, for each customer, historic information regarding rule 20bstate is held within a binary buffer that is stored within a table row that is indexed by the customer's number within the state storage medium 60. This buffer, referred to as the User Binary Block (UBB), is divided into 4 physical segments that can vary in size: the location section, the compression flag, the rule state section, and the event state section according to yet another aspect of the present invention. The Location Section holds the location and lengths of the other sections of the UBB. The Compression Flag indicates to a garbage collection process that this particular binary block has to be compressed. The Rule State Section (RSS) holds the state for rules applicable to the user. According to an aspect of the present invention, at load time, the RSS is retrieved using the location section.

[0055] Referring now to FIG. 5, the Behavior Detector 44 contains a number of internal modules that contribute to its overall processing objectives. These modules include: 1) State Restoration Module 44a; 2) The clock 44b; 3) The Inactivity Detector 44c; 4) The Time Component Checker 44d; and 5) The Match Module 44e. The Behavior Detector 44 also contains two areas of working storage, called the Working Rule State 45aand the Working Event State 45bfor manipulating pattern rules 20band the events that are active within those pattern rules 20b.

[0056] The operation of the modules within the Behavior Detector will now be explained. The clock 44bis used to keep track of time within the pattern rules 20b. The Inactivity Detector 44cmonitors the clock 44band the customer's activities and puts out events whenever a “watched for” inactivity occurs. The Time Component Checker 44dmonitors the clock 44band the individual components of each pattern rule 20bto ensure that the components meet the time constraints. The Match Module 44etakes new incoming symbols originating from either the Simple Event Detector 42, or the Inactivity Detector 44c, or from other Pattern Rules 20b, and tries to match that symbol into each of the pattern rules 20b.

[0057] Referring to FIG. 6, the Match Module 44ewill use the Working Rule State 45aand the Working Event State 45bto accomplish this task. The State Restoration Module 44auses information in the State Database 60 in order to initialize the Working Rule State 45band the Working Event State 45bwhen an individual generates a new raw event, such as a transaction. The two pieces of information that the state restoration module 44auses from the State Database 60 are the Rule State Section 62 and the Event State Section 64. The State Restoration Module 44apopulates the Working Rule State 66 from items in the Rule State Section 62 and populates the Working Event State 45bfrom items in the Event State Section 64. When all new events have been processed, that is, when no more new events are processed from the Simple Event Detector 42, or from the Inactivity Detector 44c, or from the Pattern or Behavior Detector 44, then the State Restoration Module 44aclears the Working Rule State 66 of all pattern rules 20bthat have become inactive and clears the Working Event State 45bof all events that are no longer referenced by active rules, and copies the Working Rule State 45aback into the Rule State Section 62 of the State Database 60 and copies the Working Event State 68 back into the Event State Section 64 of the State Database 60.

[0058] Each initialized item in the Rule State Section (RSS) 62 has the following exemplary fields according to yet another aspect of the present invention: Rule ID—indicates the rule for which the state applies; IsActive—indicates whether the rule is active; Counter—indicates the number of AND'd events obtained so far; Time Window—indicates the time window for matching once the earliest event has been matched; Matched events—a list of matched events, which is essentially a list of indices into an array of a Working Event State (WES) 45bas will be discussed; and, Next state—an index into the RSS 62, pointing to the next state of a multiplied instance of a rule.

[0059] Since the RSS 62 saves single rules according to one embodiment of the present invention, the multiplied instance of a rule is a feature by which one rule state section points to another rule state section as illustrated in FIGS. 7aand 7b. Referring to FIG. 7a, the Working Rule State contains all rules that the Match Module is actively trying to satisfy for an individual. The Working Event State contains all the events that the WRS refers to and all other events that have been generated by this working session of the Engine. FIG. 7ashows the WRS at the end of processing a transaction dated 8/5: “John Doe deposits $1020.” WRS contains rules 3 and 2. WES contains events 3, 4, 5, and 6. Rule 3 refers to events 3 and 6. Rule 2 refers to event 5. Referring to FIG. 7b, at the end of processing the transaction of 8/5 the Working Rule State is copied selectively to the Event State Section and the Working Event State is copied selectively to the Event State Section. Since rules 3 and 2 are both active, they are both copied. Since event 4 is not referred to by any active rule, it is not copied. The example illustrated in FIGS. 7aand 7bis further detailed in the working example, as described in the penultimate paragraph of the detailed description. Thus, in the act of arming a rule whose job is to demonstrate a sequence, a rule may collect multiple instances of events or symbols. For example, if a pattern rule is triggered by the sequence A, B, and it receives 2 A's, then it should save both of them. The reason for this is that since the rules operates within a time window, the first A may age and get cast out, i.e. expire, before a B event is received, and the rule would mistakenly not be able to demonstrate the A, B sequence even though such a sequence occurred within the time window.

[0060] As illustrated in FIG. 8, Pattern Rule 1 is configured to collect the sequence A, B, C. Times t₁<t₂<t₃. A₁arrives at t₁, A₂at t₂, and B at t₃. A₁, B satisfies the sequence A, B, C and A₂, B also satisfies the sequence A,B,C. Rule 1 points to a multiple instance of itself in order to reflect these conditions. If A₁ages past 30 days, then A₁,B will be removed and A₂,B will be the primary instance.

[0061] For example, now referring to a rule which fires upon receipt or detection of an A, B, C sequence, assuming a first event A is received at time 1, it is logged and causes a partial satisfaction of the A, B, C sequence rule. The system according to the present invention, upon restoring the state of this partially satisfied rule is waiting to receive events B and C to fully satisfy this rule. If a second event A is detected at time 2, a second instance of this partially satisfied rule is recorded. Assuming at some subsequent time 3, an event B is detected, the first recorded partially satisfied rule A, B, C can be updated. Further assuming that at some time 4, subsequent to time 3, a periodic scan of the partially satisfied rules indicates that the first recorded partial satisfaction of the rule has now expired, the recorded event B from time 3 can be discarded if the rule so requires, alternatively it can advantageously be applied to the partial satisfaction of the rule associated with the recorded event A from time 2 when the first event A from time 1 expired. In this way, the second received event A, from time 2, and event B from time 4 can still be used to satisfy the rule A, B, C if an event C is received before the second received event A analogously expires.

[0062] According to another aspect of the present invention, the system can become faster as it accumulates more data as it only needs to look for missing pieces of partially satisfied rules. For example, a rule fires upon receipt or detection of events A, B and C. Upon receipt of event B, it searches, or waits to receive input events A and C. Once event A is subsequently received or detected, then the system only needs to search for event C, and hence the further processing requirements are made simpler, which in certain instances can lead to faster processing, as will be readily understood by those possessing an ordinary skill in the pertinent art.

[0063] According to another aspect of the invention, no information is kept about disarming events. In addition to the RSS 62, each rule has a globally configured state that is kept in a common location according to another aspect of the invention. According to another aspect, the global state fields, which are settings that are held in a repository for all active rules, for each rule include: Pattern type—indicates whether the rule is set to capture sequences, AND'd groups, or OR'd groups; Multiplication flag—indicates whether multiplication mode is on; Latest/Earliest Hypothesis flag—indicates whether early or late hypothesis mode is on; and, Undo multiple states flag—indicates whether any match undoes all other states within a multiplied rule.

[0064] The Event State Section (ESS) 64 holds the state of all events that are referenced by the working rules. The location of the state is referred by the rule state items, and should not be modified once it is set, unless the garbage collection process is set upon it. At load time, this section is retrieved using information from the location section. During the restoration process, a list of free locations is also constructed.

[0065] Working Event State (WES) 45bholds the states as they are referred to by the rules in the working system. The free location list is used by the working system to grab needed new locations within the WES when new event states have been matched and must be kept around for further matching. According to an aspect of the present invention, each event that is placed in the WES has the following exemplary components: Location id—this is the location of the event in the array; Reference count—this is the number of working rules that refer to this event, where when the reference count of the rule goes to zero, the event is released from the event state section and the location goes onto the free location list; Log location—this is the location that the event was given when it was logged, where every fired event is logged; and, Time stamp—this is the time that the event was logged. Since rules have internal clocks, events have to hold onto their time stamps for the rules to manage their events as the rule ages. A free location list is a list of free locations in the working event state.

[0066] The Working Rule State (WRS) 45aholds the state of the rules during the operation of the engine 40. The working rules are ordered by rule id, and a binary search is performed to obtain the state of any rule. If the rule has not been initialized, it is filled with nulls according to one aspect of the invention.

[0067] A simple event rule 20ais a rule that transforms raw transactions 30 into simple events (symbols). This rule compares the various attribute values of the transaction against pre-configured thresholds or ranges of values. The following example of a simple event rule 20awas used earlier in the discussion of the simple event detector 42.

[0068] Rule 1093: If activity=withdraw AND amount>$10000, then generate symbol Major-Withdrawal.

[0069] In this case, the compared values are hard coded, but could have been drawn from a database of relative values. Once generated, simple events can be input into either pattern rules or the alert generator 48.

[0070] As discussed previously, a pattern rule 20bis a rule that seeks out a pattern of activity over time and generates an event or symbol that characterizes that pattern. The event generated can be input into other pattern rules 20bor the alert generator 48. Pattern rules 20bhave several components according to yet another aspect of the invention: A pattern rule has a rule name, rule ID, Rule Attributes (adjectives), Creator, and Signature. The signature is a list of symbols that the rule seeks, where the signature contains a list of all arming and disarming events that the rule seeks. A pattern rule also has an advertised signature, which is a list of those symbols that the rule still needs to fire. In the case of a non-multiplied rule, it is all those things that have yet to be matched. In the case of a multiplied rule, it is all those symbols that any partial instance of the rule needs to complete it and all events that can be used to start another instance of the rule.

[0071] A pattern rule has an internal control mechanism which directs how the rule is matched. For example, it contains mechanisms for arming and disarming the state of the rule, and control devices that dictate how the arming mechanisms behave. The patterns that can be trapped are sequences (such as this event has to happen first, that event has to happen second, etc.), AND's (such as all these events must happen, but the order of event occurrence is not important), and OR's (such as a subset of events must happen, and the order of event occurrence is not important).

[0072] A pattern rule can have undo events which are a sequence of symbols, any one of which undoes the state of the rule. Undo events can control undoing of the state based on the undo event and the current state of the rule. For example, a rule could state that it will fire upon receiving the AND'd events A,B,C, and that the rule will disarm itself if it receives the events D or E. A pattern rule can also have a time window, which is a lower and upper bound within which the rule can operate. If the pattern is not found within the time window, the rule loses its state.

[0073] For sequences, a pattern rule can also include a multiply rule flag. When this flag is set it indicates that the rule should generate multiple states of itself if it finds an event that begins the pattern again. As a further refinement to the multiply rule flag, the rule employs the latest hypothesis wins flag, the earliest hypothesis wins flag, and the undo multiple rules flag. An hypothesis is a list of events that arm the rule on the way to eventual rule firing. The latest hypothesis wins flag indicates that a previous hypothesis should be removed when any hypothesis acquires a state that is at least as great as a previous hypothesis. For example, if a rule is looking for the sequence ABC, and is holding hypotheses S1={AB}, and S2={A}, then when event B arrives S2 moves to state {AB} and, since S2 is equal to S1, and since S2 is a later hypothesis than S1, then hypothesis S1 is removed.

[0074] Intuitively, this setting is meant to catch the most recent sequence. When the earliest hypothesis wins flag is set, every event that starts or extends an existing hypothesis is captured, and the earliest hypothesis wins. This mode demonstrates the complete multiplicity of rule state. It holds onto an event that can complete a sequence. When the sequence fires, the oldest hypothesis is completed and removed, and the next oldest hypothesis takes its position. The undo multiple rules flag is viable when “Multiple Rule Flag” is true, and when set undoes all partial instances of the rule when an undo event appears. A pattern rule further includes an IsActive Flag to indicate whether the rule is active or not. An inactive rule does not entertain any activity. A rule can become inactive for a variety of reasons. For example, the control mechanism of a rule may be configured so that once fired, the rule falls into an inactive state that is monitored by a customer-specific timer. When the timer expires, the rule is set back to active. Alternatively, a management facility may control activating rules that have seasonal or other time dependencies.

[0075] Finally, the firing of a rule generates a characterization of captured behavior. The result of the fired rule is an event that can be fed back into the system as an input into another pattern rule. In the process of generating this event, the rule records the actual events that instantiated it, and resets itself to seek for more patterns of the same activity.

[0076] The transaction log 80 is an addressable file or database that holds a record of raw transactions that have been transformed by a simple rule, partially completed pattern-rule states that are advancing toward pattern completion and rule firing, and completed pattern-rule states that have been fired by a pattern rule. The transaction log 80 keeps a record of rule firings and can be used to provide data for reporting or for justification of rule firings. According to an aspect of the invention, for each pattern rule that fires, the log contains the essentials of the event that fired, i.e., the customer id, the symbol created, the timestamp, and the rule that generated it; a list of all arming events, in arming signature order; and a flag stating whether the event was used by any downstream pattern or action. For each match, whether it is an arming or disarming event, the following is recorded in the log: the rule that grabbed the: match; the item in the rule that the match occurred on.; and, the log id of the item that matched. According to one aspect of the invention, the logging of a firing waits for the first match to occur. It then logs itself, and grabs an address. This address is now available for matching events to refer to. If the match never occurs, the firing will get logged after all matches fail with a flag stating that no match occurred.

[0077] For example, the following is a scheme for recovering a detailed report about a rule firing. A fired rule records its state in the transaction log 80 and the Working Event State (WES) resets its state to “nothing matched within.” At any time, a completely specified chain of events, including all intermediate events and the original transactions, can be reconstructed from the log for any fired event. For example, a log contains within it the following records:

[0078] XO: Raw Transaction 0, (Visitor, Date, Details), (1)

[0079] X1: Raw Transaction 1, (Visitor, Date, Details), (1)

[0080] X2: (C, S2, R2, T2), (0, X0), (1)

[0081] X3: (C, S3, R3, T3), (X1), (1)

[0082] X4: (C, S4, R4, T4), (X3), (0)

[0083] X5: (C, S5, R5, T5), (X3, 0, X2), (0)

[0084] where, X is a log location, C is a visitor id, S is a symbol, R is a rule, T is a timestamp followed by the triggering event identifiers and (0/1) indicates whether a rule was used in downstream matching.

[0085] Using the transaction log 80, one can trace back on event (C, S5, R5, T5). The details of the transaction log 80 are used for working back through the log and uncovering all details of rule firings that led to the creation of an event. In the previous example: (1) Rule R5 fired symbol S5 at time T5. The first parameter of the rule matched event X3 and the third parameter of the rule fired on event X2. The second parameter of the rule was unmatched. The (1) indicates that this event was matched in some downstream rule, not shown here; (2) Rule R3 fired symbol S3 at time T3. The first parameter of the rule matched event X1. The (1) indicates that this event was matched in a downstream rule, which we know from the log was event R5; (3) Rule R2 fired symbol S2 at time T3. The first parameter of the rule was unmatched and the second parameter of the rule matched event X0; and, (4) If, for the event logged at location X5, all references to log locations are replaced with the contents of those log locations, (e.g., replacing X3 with contents of the log location X3), we get the expanded form: (C, S5, R5, T5), ((S3, R3, T3), (Raw Xaction1)), 0, ((S2, R2, T2), (Raw Xaction0)). It should also be noted that event X4 is marked with a (0), denoting that it was not used in any downstream matches, including action rules, which are not mentioned here.

[0086] It should be recognized that the present invention is different from these other typical rule-based systems and state-keeping systems. For example, with regard to expert systems in the traditional rule-based approach, events are fed into the system, rules grab whatever is relevant, and generate results that are forward-chained back into the system. The system continues until no more rules fire. The results that are left are the system's output. When new events arrive, the system is rerun, pulling in as much old event information as is thought relevant (old events are required since some rules may require a mixture of old and new events in order to arrive at the sought after conclusions.) Within the expert system approach, the procedure of using old events is fraught with difficulty, since past processing may have used an event in such a way that the event can no longer be used in the future. The management of the processing of old and new information adds great complexity to the system, since it requires the addition of new rules that are outside the problem domain that are crafted only to control the behavior of the system.

[0087] In contrast to the aforementioned difficulties, the present invention advantageously holds all relevant information that enters the system within the state of its rules, and eliminates the need to reprocess old information when new information arrives. Since the present invention processes incoming events only once, there is no need to introduce unnecessary rules to control the behavior of the system upon information that had already been processed. This queue-like treatment of all event information that passes through the system, introduces a time element that is lacking in the traditional expert system.

[0088] With regard to conventional database queries, database systems typically hold data in a secure and non-redundant fashion. The present invention not only holds data, but also builds up new information depending upon the data it receives and the order in which the data is received. If a typical database system were to mimic this behavior, new table rows would have to be generated with the new information, and rules would be required to decide which of this information was most relevant in view of the total state of the system. By manipulating the old data, it would have to mark which of this data was used and how it aged. In that instance, the behavior of the present invention would essentially have to be an application implemented on top of the database in a very cumbersome way.

[0089] With regard to database triggers, which allow for the triggering of procedural actions when changes occur to information within the database tables, there are several important points of distinction between a database with triggers and the present invention. For example, a database with rules operates in close conjunction with the underlying data format, which makes it difficult to express high-level rules. In contrast, the present invention allows rich composition of rules at all levels of abstraction. A database with rules needs to generate and manage increasingly more information in order to track what the system has already done with historical information—rendering the system inefficient. In contrast, the present invention maintains state as a natural part of the computation. In a database with rules, as with other database trigger systems, the lack of centralized management makes rule validation and scope analysis difficult. In contrast, the present invention has a single, centralized rule management capability that provides powerful reporting, validation, and administration functions. Unlike the present invention, a common database trigger system is typically programmable by a professional technician, whereas the present invention is programmable by non-technical staff. By its very nature, a database trigger system builds a dependency to a single database technology. The present invention employs an open architecture that supports multiple databases and other data sources through open interfaces. Further, the present invention is not limited to data sources that are in the form of databases.

[0090] With regard to state machines, which generally contain a number of states, a unique initial state called “start,” a set of events, and a specification of how events move the machine from one state to another, as events stream into the system, the machine is always in a unique state called the “current state.” As in the present invention, a state machine does not review old events that have already been acted upon by the system. The present invention is different from a state machine, but it operates however, similarly to multiple state machines, since the output from one generating events that may drive another one of the machines to another state.

[0091] The present invention is also different from a state machine in that multiple results may be returned from the system. The present invention is also different from a state machine in that it clearly records and utilizes the path, or sequence of arming events, that brings a rule to its current state, where a finite state machine tracks only the current state but not the history that brought it to the current state. Any one of multiple paths may bring a finite state machine to it current state; and by its very nature, a finite state machine fails to recognize these paths.

[0092] According to an aspect of the invention, the system can be implemented on a Windows 2000 platform using a Microsoft SQL 7 database. Of course, any other suitable platform, programming language, or commercial database can be utilized. The following discussion describes a non-limiting example of a detailed design consistent with the present invention using pseudo code, for the sake of explanation.

[0093] Input events 30 to the system 10 are taken from a set of valid symbols. It is presumed that the valid symbols consist of the 26 letters of the alphabet so there is no need for the simple event detector 42 to map complex transactions into simple events. The input events 30 themselves are ordered and considered open-ended, which means that the system may pause because of lack of input, but doesn't comes to a halt. According to one aspect of the invention, the input events 30 are read from a queue. New data is added to the queue whenever a rule fires or when new information comes into the system from the outside.

[0094] For this implementation, input is held within a data structure called InputClass and is defined as follows:

[0095] Class InputClass {

[0096] List of Symbol input;

[0097] Integer cursor;

[0098] Void resetCursor( );

[0099] Symbol getNextInput( );

[0100] Boolean haveMoreInput( );

[0101] Void addNewInput( )

[0102] }

[0103] For this implementation, rules are held within a data structure called a ruleClass and is defined as follows:

[0104] Class ruleClass {

[0105] List of Symbols Preconditions;

[0106] Symbol Action;

[0107] List of Symbols Precondition_History;

[0108] Integer id;

[0109] Boolean match(Symbol);

[0110] Boolean isCompletelyMatched( );

[0111] Symbol fire( );

[0112] Void reset( );

[0113] Integer getRuleID( );

[0114] }

[0115] RuleClass holds within it a list of preconditions and a predetermined action. During its lifetime, it manages its own state in a data structure called the precondition-history. It contains five functions: (1) match: checks if an incoming symbol is needed by the preconditions but not yet contained within the precondition-history; (2) areAllPreconditionsMatched: checks if all the preconditions have been met; (3) fire: returns the action symbol when all of the preconditions have been met. It also resets the state of the rule; (4) reset: clears out the precondition-history; and, (5) getRuleld: returns the id.

[0116] A rule set is a collection of all the rules that the engine acts upon. An example of a rule set would be:

[0117] A&B→C

[0118] B&D→F

[0119] C&G→H

[0120] For this implementation, a rule set is contained within a data structure called a RulesetClass and is defined as follows:

[0121] Class RulesetClass {

[0122] List of Rule rules;

[0123] Integer cursor;

[0124] Void resetCursor( );

[0125] Rule GetNextRule( );

[0126] Boolean hasMoreRules( );

[0127] Void addNewRule(ruleClass);

[0128] }

[0129] RulesetClass holds within it a list of rules. It manages access to these rules through a cursor model that allows the user of the class to access one rule at a time from the beginning of the rule set to the end. In order to accomplish this it holds an internal index into the rules called the cursor. It contains four functions: (1) resetCursor: resets the cursor to the beginning of the rule set; (2) getNextRule: returns the next rule in the rule set; (3) hasMoreRules: returns true if there is another rule to return to the user; and, (4) addNewRule: adds a new rule to the rule set.

[0130] The engine 40 takes input events 30 from the input queue, and feeds them to the rules 20 within the rule set. The input events 30 that pass through the system 10, or are generated by the system 10 but not consumed by it, are the system's results 50. For this implementation, the results 50 are contained within a data structure, called the ResultsClass, that is defined as follows:

[0131] Class ResultsClass {

[0132] List of Symbols results;

[0133] Integer cursor;

[0134] Void resetCursor( );

[0135] Symbol getNextResult( );

[0136] Boolean hasMoreResults( );

[0137] Void addNewResult(symbol);

[0138] }

[0139] The ResultsClass holds within it a list of symbols, or results. It manages access to these results through a cursor model that allows the user of the class to access one result at a time from the beginning of the results to the end. In order to accomplish this it holds an internal index into the results called the cursor. It contains four functions: (1) resetCursor: resets the cursor to the beginning of the rule set; (2) getNextResult: returns the next result in the list of results; (3) hasMoreResults: returns true if there is another result to return to the user; and, (4) addNewResult: adds a new result to results.

[0140] For this implementation, the following procedure, called ProcessNewInput, processes input that has been put onto the input queue from an external system.

[0141] The main engine: waits for input from the outside; retrieves the user's history using the userid; restores the state of the rules using the history; processes new input in the context of the history; extracts the history from the rules; saves the history; resets the rules to leave them stateless for the next user; and, processes the results.

[0142] Void mainEngine( ) {

[0143] RulesetClass Rules;

[0144] Rules=FetchRulesFromRulesStorage( );

[0145] While (True) {

[0146] Input, Userid=WaitForNewInputFromOutside( );

[0147] History=FetchUserHistory(Userid);

[0148] Rules RestoreStateOfRules(History)

[0149] Result ProcessNewInput(Input, Rules);

[0150] History=ExtractUserHistory(Rules);

[0151] SaveUserHistory(History);

[0152] Rules.reset( );

[0153] Process(Userid, Result);

[0154] }

[0155] }

[0156] In another example, the present invention operates on information for an individual person and is given a single rule that states, for example, if a person buys a chair and a desk then give him a free pen. The system receives an event that the person purchased a desk. The system activates the above rule and captures within the rule that a desk was purchased. The system later receives an event that the person purchased a chair. The system does not retrieve the old event that records that a desk was bought and run the engine on this event. Instead it restores the state of the above rule and processes the purchase of chair event. It calculates immediately that the rule is completed by the purchase of the chair. The rule is satisfied and fires its action, offering the person a free pen.

[0157] In another example, the system handles aging information without the need for additional control rules. The present invention is given the following pair of rules, which operate on the sales events of a given customer: (1) if the person buys an item for $50 then send him a $10 gift certificate; and, (2) if the person buys an item for $50 and an item for $25 then offer him a credit card. On day 1, the person buys a chair for $50 and is issued a $10 gift certificate from the first rule. The second rule holds on to the state that one $50 item was purchased. On day 2, the person buys a pen for $25. The state of the second rule is restored and the person is offered a credit card. As will be recognized by those possessing an ordinary skill in the art, the present invention works as intuitively expected without the need of additional rules to control overall behavior. In contrast, in a typical rules-based system, the person would have been offered another $10 gift certificate on the second day since the $50 purchase would have to have been retrieved and run through the system again in order to supply sufficient information to fire the second rule. This would have been an error, which, in order to be corrected, would have required the addition of a control rule into the system that would state: (3) if the person was offered a $10 gift certificate, do not offer it to him again. In addition, the system would had to have recorded that a $10 gift certificate was given and have made it available to the system for processing on the second day's run.

[0158] What follows is an operational, non-limiting, working example of the present invention.

[0159] The following is a start to finish example showing the current invention processing events over time with the purpose of demonstrating the end-to-end workings of the system.

[0160] Domain—The current invention will be demonstrated in a financial services domain. The transactions that will be fed into the system show a sequence of transactions on behalf of John Doe, a financial services customer. The transactions, which occur over a 5-month period, will trigger a sequence of rules that will eventually determine that John Doe has been triggered to be a Good Customer according to the criteria set forth in the following rules:

[0161] Good Customer Rules—A customer becomes a good customer if the following is true:

[0162] He is over 21 years old

[0163] He deposits over $1000 in his savings account during each month over a 3-month period.

[0164] The following strategy will be used in order to track this good customer conduct:

[0165] Transactions arrive that record deposits and withdrawals and the amount of money transacted to John Doe's savings account. These transactions will be tracked.

[0166] A pattern of $1000 deposits to the account will be tracked. If a month occurs with no deposit of at least $1000, the pattern will be undone.

[0167] The following rules will be input into the current invention in order to track the good customer conduct:

[0168] Rules that generate simple events—The following rule will monitor incoming transactions and generate the simple event ThousandDollarDeposit.

[0169] Rule 1: Thousand Dollar Deposit Rule

[0170] Description: It is assumed that there is a database of customer attributes, (referred to as the “static data” in the architecture), that contains a field called the “Age” value, and that this rule checks its value when it encounters the phrase “customer Age”. It is also assumed that various attributes come in on the transaction and that the rule can check the value of those attributes. The transactions that we will be considering will have two attributes that the rule will check:

[0171] Kind—states whether the transaction is equal to a deposit or a withdrawal.

[0172] Amount—state the amount of the transaction.

[0173] Rule1 checks that the transaction “kind” is equal to “deposit” and that the transaction “amount” is greater than $1000. (For simplicity sake, all transactions will be of “kind” deposit.) The output of the rule is the simple event ThousandDollarDeposit.

[0174] RuleID: 1

[0175] If customer Age>=21 And

[0176] Transaction.Kind=Deposit And

[0177] Transaction.Amount>$10000

[0178] Then Generate Event ThousandDollarDeposit

[0179] Rules that track behaviors—The following rules monitor behaviors and trends and generate compound events.

[0180] Rule 2: Deposited Thousand Dollars This Month Rule

[0181] Description: This rule operates within a one-month period. It watches for simple events marked ThousandDollarDeposit and generates a DepositedThousandDollarsThisMonth event. The value that it adds above the “Thousand Dollar Deposit Rule” is the one-month time processing window. This time processing takes two forms:

[0182] 1. If a month expires before the rule fires, then it will generate another event called the Not DepositedThousandDollarsThisMonth event. This negative event will propagate to the “Three Month Rule” below and undo the buildup of information that three straight months of depositing have occurred.

[0183] 2. The rule will only fire once a month. This prohibits three deposits of $1000 within one month from being construed as three deposits of $1000 over three months.

[0184] RuleID: 2

[0185] If (within the period of a month)

[0186] In Sequence: System generates FirstOfMonth

[0187] And Customer generates ThousandDollarDeposit

[0188] Then Generate Event DepositedThousandDollarsThisMonth

[0189] Upon Expiration of Month

[0190] Then Generate Event Not

[0191] DepositedThousandDollarsThisMonth

[0192] Inhibit Once Fired Until Next Month Begins

[0193] Rule 3: Deposited Thousand Dollars Over Three Months Rule

[0194] Description: This rule operates within a three-month period. It watches for output from the “Deposited Thousand Dollars This Month Rule” and when it has seen three of them, it generates the DepositedThousandDollarsOverThreeMonths event. The receipt of a Not DepositedThousandDollarsThisMonth event can undo the process of counting three $1000 deposits over three months and set the state of this rule back to empty.

[0195] RuleID: 3

[0196] If (within the period of 3 1174 months)

[0197] Customer generates DepositedThousandDollarsThisMonth

[0198] Then Generate Event

[0199] DepositedThousandDollarsOverThreeMonths

[0200] ReleaseState If Customer generates Not

[0201] DepositedThousandDollarsThisMonth

[0202] Rules that generate an action—This action rule looks for either simple or complex events and triggers the “GoodCustomer” behavior. The result of the triggering will be recorded in a log, but it could just as well add a line to a database, or a message sent to an external system.

[0203] Rule 4: Trigger GoodCustomer Rule

[0204] Description: This rule looks for the DepositedThousandDollarsOverThreeMonths event which is generated by Rule 3, and triggers the GoodCustomer value to be written to a log on behalf of the customer that exhibited the behavior.

[0205] RuleID: 4

[0206] If customer generates DepositedThousandDollarsOverThreeMonths

[0207] Then write “Customer<name>

[0208] Date <today's date>

[0209] Triggered GoodCustomer”

[0210] Rules that generate time-dependent events—The following rules will generate events periodically.

[0211] Rule 5: Generate First of the Month Rule

[0212] Description: This rule generates a FirstOfMonth event at the beginning of every months. Rule2, the “Deposited Thousand Dollars This Month,” will use it to starts its monthly watch for a deposit of a thousand dollars.

[0213] RuleID: 5

[0214] If First of the month

[0215] Then Generate Event FirstOfMonth

[0216] Transactions—XML is the vehicle for conveying the content of the transaction, although they could have been conveyed in other ways. For example, the transactions could have been represented as a database record or a fixed field record. Transactions have the form:

[0217] <TRANSACTION>

[0218] <CUSTOMER_ID>1234</CUSTO

[0219] MER_ID>

[0220] <KIND>deposit</KIND>

[0221] <DATE>Jun. 20, 2000</DATE>

[0222] <DETAILS>

[0223] <AMOUNT>$734</AMOUNT>

[0224] <LOCATION>Bank 234, Princeton, NJ</LOCATION>

[0225] </DETAILS>

[0226] <TRANSACTION>

[0227] This states that the customer, whose id is 1234 (John Doe), deposited $734 into a Princeton bank on Jun. 20, 2000. In order to simplify the incoming transactional information, the following table lists the essence of the deposits that John Doe made over a series of months. For simplicity sake, the “kind” of transaction is omitted and is assumed to be always equal to “deposit”.

[0228] THE SYSTEM AT WORK—On May 5, 2000, the static data store has recorded within it that John Doe is 30 years old. (So the rule that requires that the customer be at least 21 years old will always be satisfied.) After the system processes transactions 1 through 6, it will trigger a message on Sep. 5, 2000 that John Doe is a GoodCustomer. It is easy to look at the transactions and reason why this determination is made—John Doe made three months of deposits over $1000 starting in July and ending in September. The following discussion reveals how the system made this same determination. Transactions will be abbreviated to TN. We will show the internal workings of the current invention by tracing the following activities:

[0229] 1. Working Event State—this shows all the events that are active on behalf of a single visitor while the system is active for that visitor.

[0230] 2. Working Rule State—this shows the state of the rules after the rules finish processing any event that impacts their state.

[0231] 3. Event State Section—this shows the visitor events that are saved out to disk when the rules for that visitor are swapped out of service. The Event State Section will contain a subset of the events from the Working Event State, and will leave out those events that are no longer referenced by any of the rules that are holding state.

[0232] 4. Rule State Section—this shows the state of the rules when a visitor's history is copied out to disk. This section will contain initially an identical copy of the Working Rule State after the last visitor event is processed. Offline processing of rules containing time-sensitive constraints may change the contents of the Rule State Section in between periods of transaction processing.

[0233] 5. Transaction Log—this shows every arming or firing of rules within the current mechanism. The log offers a more complete picture of the mechanism than can be observed by tracing the activities in the event and rule state sections, since the working states reveal the mechanism for only those parts of the current invention that hold state, and would not reveal the operation of the simple event rules and the action rules, since they do not hold state.

[0234] The following abbreviations will be used:

[0235] WES—Working Event State

[0236] WRS—Working Rule State

[0237] ESS—Event State Section

[0238] RSS—Rule State Section

[0239] TN n—Transaction n

[0240] TL—Transaction Log

[0241] The following structure, called an Event State Structure, will be used to describe the state of a single event in the WES and ESS. The complete WES and ESS will be made up of a set of Event State Structures.

[0242] Location id—The location of the event in the data structure that holds the entire set of events. If the working events are held in an array, then the location id is an array index.

[0243] Reference count—The number of working rules that refer to this event. When the reference count goes to zero, the event is removed from the event state section.

[0244] Log location—The location in the log where this event was logged.

[0245] Time stamp—The timestamp of the logged event. It is used during run-time in order to do event timestamp checking.

[0246] The following structure, called a Rule State Structure, will be used to describe the state for a single rule in the WRS and the RSS. The complete WRS and RSS will be made up of a set of Rule State Structures.

[0247] Rule ID—the rule id for the rule. For the current rule set, the ids will range from 1-5.

[0248] IsActive—this flag states whether a rule is active within the system. (A reason for a rule to not be active, for instance, is if it were to be used only during a holiday season.) For all the rules used in this example the IsActive flag will always be true.

[0249] Counter—indicates the number of and'd events obtained so far. This flag will not play a part in the rules discussed here.

[0250] Time Window—indicates the time window for matching once the earliest event has been matched.

[0251] Matched events—a list of matched events. This is essentially a list of indices into the array of the working event state. The order of the list is the same as the list of arming parameters in the rule's signature. Note that no information is kept about disarming events.

[0252] Next state—an index into the Working Event State, pointing to the next state of a multiplied instance of this rule. For the current example, there will be no rules that maintain a multiplied instance of themselves, and the “Next State” field will always be null.

[0253] As the activities of the current invention are traced from transactions 1-6, the following will be shown:

[0254] Every log entry

[0255] The WES and the WRS for every change in the state of the current invention. There will typically be many changes to the WES and WRS for each transaction, as the transaction moves through the simple event detection rules, the pattern detection rules, and the action rules.

[0256] The ESS and the RSS after the current invention runs its course in processing a single transaction. The ESS and RSS contain that state that must be restored when a new transaction arrives and that state that must be saved after all processing initiated by that transaction completes.

[0257] TN 1: On 5/5, the following occurs:

[0258] We assume that there has been no activity prior to transaction 1 and consequently the ESS and the RSS are empty. Summary: TN1 gets logged, initiates the firing of Rule1 and Rule2, and the arming of Rule3.

[0259] TN1 gets logged as follows:

[0260] 1: (1234, (Deposit, $1020), RT, 5/5), ( ), (1)—This is to be read as follows:

[0261] 1: (1234, (Deposit, $1020), RT, 5/5), ( ), (1)—This is the location in the log, in this case it is location 1.

[0262] 1: (1234, (Deposit, $1020), RT, 5/5), ( ), (1)—This is John Doe's id.

[0263] 1: (1234, (Deposit, $1020), RT, 5/5), ( ), (1)—These are the details of the transaction, in this case, John deposited $1020.

[0264] 1: (1234, (Deposit, $1020), RT, 5/5), ( ), (1)—This uses the RT code to signify that this was a raw transaction, one that was generated by an external system, and no rule was required to create this event.

[0265] 1: (1234, (Deposit, $1020), RT, 5/5), ( ), (1)—This is the date of the transaction.

[0266] 1: (1234, (Deposit, $1020), RT, 5/5), ( ), (1)—This states that the raw event is a basic event and did not match any incoming events.

[0267] 1: (1234, (Deposit, $1020), RT, 5/5), ( ), (1)—This states that the result of the firing was used in downstream processing.

[0268] WSS is empty.

[0269] WES contains:

[0270] LocationID: 1

[0271] ReferenceCount: 0

[0272] LogLocation: 1

[0273] TimeStamp: 5/5

[0274] John Doe is over 21 years old; Rule 1 transforms TN1 to the simple event ThousandDollarDeposit. The following gets logged into TL:

[0275] 2: (1234, ThousandDollarDeposit, Rule1, 5/5), (1), (1)—This is to be read as follows:

[0276] 2: (1234, ThousandDollarDeposit, Rule 1, 5/5), (1), (1)—This is the location in the log; in this case it is location 2.

[0277] 2: (1234, ThousandDollarDeposit, Rule1, 5/5), (1), (1)—This is a package that gives information about the event that was generated. It states that: for customer 1234, Rule1 generated the ThousandDollarDeposit Event at 6PM on 5/5.

[0278] 2: (1234, ThousandDollarDeposit, Rule1, 5/5), (1), (1)—This signifies that Rule 1 matched against the item at location 1 in the log.

[0279] 2: (1234, ThousandDollarDeposit, Rule1, 5/5), (1), (1)—This states that the result of the firing was used in downstream processing. That is, it will be used to match against Rule 2 below.

[0280] WRS remains empty since Rule1 fires immediately and does not save its state. (State is saved only when rules arm, not when they fire).

[0281] ESS contains:

[0282] LocationID: 1

[0283] ReferenceCount: 0 (Even though this event was referenced by

[0284] Rule1, Rule1's state did not get put into the WRS and therefore the reference count of this event was not incremented).

[0285] LogLocation: 1

[0286] TimeStamp: 5/5

[0287] LocationID: 2

[0288] ReferenceCount: 0 (No rules have yet armed on this event.)

[0289] LogLocation: 2

[0290] TimeStamp: 5/5

[0291] Rule2 accepts the ThousandDollarDeposit from the firing of Rule 1, and generates the DepositedThousandDollarsThisMonth event. The following gets logged into TL:

[0292] 3: (1234, DepositedThousandDollarsThisMonth, Rule2, 5/5), (2), (1)—This is to be read as follows:

[0293] 3: (1234, DepositedThousandDollarsThisMonth, Rule2, 5/5), (2), (1)—This event is logged in location 3 in the log.

[0294] 3: (1234, DepositedThousandDollarsThisMonth, Rule2, 5/5), (2), (1)—This is a package that gives information about the event that was generated. It states that: for customer 1234, Rule2 generated the DepositedThousandDollarsThisMonth event at 6PM on 5/5.

[0295] 3: (1234, DepositedThousandDollarsThisMonth, Rule2, 5/5), (2), (1)—This signifies that the event in location 2 matched Rule2.

[0296] 3: (1234, DepositedThousandDollarsThisMonth, Rule2, 5/5), (2), (1)—This signifies that this event was used in downstream processing. That is, it will be used to match against Rule3 in the next bullet.

[0297] WRS contains:

[0298] RuleID: 2

[0299] IsActive: Yes

[0300] Counter: 2

[0301] TimeWindow: 5/1-5/30

[0302] MatchedEvents: 2

[0303] HasFired: Yes

[0304] NextState: Null

[0305] WES contains:

[0306] LocationID: 1

[0307] ReferenceCount: 0

[0308] LogLocation: 1

[0309] TimeStamp: 5/5

[0310] LocationID: 2

[0311] ReferenceCount: 1

[0312] LogLocation: 2

[0313] TimeStamp: 5/5

[0314] LocationID: 3

[0315] ReferenceCount: 0

[0316] LogLocation: 3

[0317] TimeStamp: 5/5

[0318] Rule3 accepts the DepositedThousandDollarsThisMonth event and partially arms the rule. (The rule does not fire since this event is only the first of three required.) The following gets logged into the TL:

[0319] 4: (1234, 0, Rule3, 5/5), (3,0,0), (0)—This is to be read as follows:

[0320] 4: (1234, 0, Rule3, 5/5), (3,0,0), (0)—This event is logged in location 4 in the log.

[0321] 4: (1234, 0, Rule3, 5/5), (3,0,0), (0)—This is a package that gives information about what happened inside the rule. It states that: for customer 1234, Rule3 was partially armed at 6PM on 5/5.

[0322] 4: (1234, 0, Rule3, 5/5), (3,0,0), (0)—This states that the state of the rule was set to “3,0,0” after the rule finished executing. This means that Rule 3 has three arguments to be matched, and that the first item to be matched is matched against item 3 in the log, and that the other two items to be matched have not yet been matched. (The 0 value indicates that nothing was matched yet.)

[0323] 4: (1234, 0, Rule3, 5/5), (3,0,0), (0)—This signifies that the current invention did not use anything that happened here in any downstream processing. (This is clear, since the rule was simply armed and did not even fire an event that could be used in downstream processing. In other cases this distinction is not as straightforward, and a rule may fire an event that is not used by any other rule.)

[0324] WRS contains:

[0325] RuleID: 2

[0326] IsActive: Yes

[0327] Counter: 2

[0328] TimeWindow: 5/1-5/30

[0329] MatchedEvents: 2

[0330] HasFired: Yes—Keep alive for inhibition

[0331] NextState: Null

[0332] RuleID: 3

[0333] IsActive: Yes

[0334] Counter: 0

[0335] TimeWindow: 5/5-8/5 (Once armed, has time window of 3 months)

[0336] MatchedEvents: 3

[0337] HasFired: No

[0338] NextState: Null

[0339] WES contains:

[0340] LocationID: 1

[0341] ReferenceCount: 0

[0342] LogLocation: 1

[0343] TimeStamp: 5/5

[0344] LocationID: 2

[0345] ReferenceCount: 1

[0346] LogLocation: 2

[0347] TimeStamp: 5/5

[0348] LocationID: 3

[0349] ReferenceCount: 1

[0350] LogLocation: 3

[0351] TimeStamp: 5/5

[0352] Building up the ESS from the WES, and the RSS from the WRS—the Rules State Section (RSS) is derived directly from the Working Rules State (WRS). The Event State Section (ESS) is derived from the Working Event State (WES) in the following fashion: Any event that has a reference count that is equal to 0 no longer has to be saved, since the zero setting indicates that no working rule refers to the event. In this case, the WES event with LocationID 1 has a reference count equal to zero and will be removed from the ESS.

[0353] RSS contains:

[0354] RuleID: 2

[0355] IsActive: Yes

[0356] Counter: 2

[0357] TimeWindow: 5/1-5/30

[0358] MatchedEvents: 2

[0359] HasFired: Yes—Keep alive for inhibition

[0360] NextState: Null

[0361] RuleID: 3

[0362] IsActive: Yes

[0363] Counter: 0

[0364] TimeWindow: 5/5-8/5 (Once armed, has time window of 3 months)

[0365] MatchedEvents: 3

[0366] HasFired: No

[0367] NextState: Null

[0368] ESS contains:

[0369] LocationID: 2

[0370] ReferenceCount: 1

[0371] LogLocation: 2

[0372] TimeStamp: 5/5

[0373] LocationID: 3

[0374] ReferenceCount: 1

[0375] LogLocation: 3

[0376] TimeStamp: 5/5

[0377] This ends the processing that occurred because of TN1.

[0378] Time Event: On 6/1 the following occurs. Rule2, which was being kept alive by an inhibition in effect until 5/30, expires and is removed from the RSS. The removal of Rule2 brings down the reference count for the event with LocationID 2, decrements its reference count to 0, and forces it to be removed from the ESS. (Note that the removal of the state of Rule2 removes the inhibition that it was enforcing and paves the way for Rule2 to fire again.) These changes are reflected as follows:

[0379] RSS contains:

[0380] RuleID: 3

[0381] IsActive: Yes

[0382] Counter: 0

[0383] TimeWindow: 5/5-8/5 (Once armed, has time window of 3 months)

[0384] MatchedEvents: 3

[0385] HasFired: No

[0386] NextState: Null

[0387] ESS contains:

[0388] LocationID: 3

[0389] ReferenceCount: 1

[0390] LogLocation: 3

[0391] TimeStamp: 5/5

[0392] TN 2: On 6/5, the following occurs:

[0393] The ESS and the RSS contain the same contents that they had after the time event of 6/1. The WES and the WRS are derived directly from them. Summary: TN2 gets logged but does not prompt the firing of any of the rules. This is because the simple event detection rules look only for deposits that are greater than $1000, and this deposit is only $920.

[0394] TN2 gets logged as follows:

[0395] 5: (1234, (Deposit, $920), RT, 6/5), ( ), (0)—This is to be read as follows:

[0396] 5: (1234, (Deposit, $920), RT, 6/5), (0)—The transaction is logged into location 5 in the log.

[0397] 5: (1234, (Deposit, $920), RT, 6/5), (0)—These are the details of the transaction. In this case, user 1234 deposited $920 on 6/5. The RT indicates that no rule originated this transaction. (This is an elemental transaction that was generated by an external system.)

[0398] 5: (1234, (Deposit, $920), RT, 6/5), ( ), (0)—The zero here indicates that the transaction did not trigger any rule firings. This is clear from the fact that our only simple event rule, Rule 1, is only looking for transactions of over $1000, and this transaction does not meet that criteria.

[0399] The RSS and the ESS remained unchanged.

[0400] RSS contains:

[0401] RuleID: 3

[0402] IsActive: Yes

[0403] Counter: 0

[0404] TimeWindow: 5/5-8/5 (Once armed, has time window of 3 months)

[0405] MatchedEvents: 3

[0406] HasFired: No

[0407] NextState: Null

[0408] ESS contains:

[0409] LocationID: 3

[0410] ReferenceCount: 1

[0411] LogLocation: 3

[0412] TimeStamp: 5/5

[0413] Time Event: On 6/30 the following occurs:

[0414] A time event occurs that causes the WES and WRS to be restored for customer 1234. (They are identical to the RSS and ESS above, i.e., RSS contains RuleID=3 and ESS contains LocationID=3.)

[0415] Summary: Rule2, which had been armed by the FirstOfMonth event, expires and generates a Not DepositedThousandDollarsThisMouth event. This in turn propagates to Rule 3, which discards its state and logs the following:

[0416] 6: (1234, Not DepositedThousandDollarsThisMonth, Rule3, 6/30), (0), (0)—This is to be read as Rule3 processing the “Not DepositedThousandDollarsThisMonth” on June 30, and resetting its state to “no state” (signified by the second to the last “(0)”). The last “(0)” indicates that no downstream rules use the result of disarming Rule 3.

[0417] At this point, the stateful Rule3 is unarmed and the current invention is back to its initial state before the firing of the first transaction on 5/5. The chain of internal mechanism changes is as follows: the state of Rule3 loses “Y” as a “MatchedEvents”. Rule3, having no state, loses the right to have its state held onto and the Reference count for Event 3 goes down to 0. As a consequence, the WES and the WRS revert to null; and the ESS and the RSS revert to null.

[0418] TN 3: On 7/5, the customer deposits over $1000 and the system responds in a way that is identical to the way it responded to TN1 on 5/5. The following events are logged in the process of restoring the system to the state where it is holding one relevant transaction.

[0419] The following logged events detail the workings of the current invention:

[0420] TN3 gets logged as follows:

[0421] 7: (1234, (Deposit, $1020), RT, 7/5), ( ), (1)—This is to be read as follows:

[0422] The original customer event of depositing $1020 is logged in location 7. This is an external event that starts the chain reaction of rule reaction and further events firing.

[0423] WSS is empty.

[0424] WES contains:

[0425] LocationID: 1

[0426] ReferenceCount: 0

[0427] LogLocation: 7

[0428] TimeStamp: 7/5

[0429] John Doe is over 21 years old, Rule 1 transforms TN1 to the simple event ThousandDollarDeposit. The following gets logged into TL:

[0430] 8: (1234, ThousandDollarDeposit, Rule1, 7/5), (7), (1)—This is to be read a

[0431] Rule 1 accepts event 7 and generates the ThousandDollarDeposit event.

[0432] WRS remains empty since Rule1 fires immediately and does not save its state. (State is saved only when rules arm, not when they fire.)

[0433] WES contains:

[0434] LocationID: 1

[0435] ReferenceCount: 0 (Even though this event was referenced by Rule1, Rule1's state did not get put into the WRS and therefore the reference count of this event was not incremented.)

[0436] LogLocation: 7

[0437] TimeStamp: 7/5

[0438] LocationID: 2

[0439] ReferenceCount: 0 (No rules have yet armed on this event.)

[0440] LogLocation: 8

[0441] TimeStamp: 7/5

[0442] Rule2 accepts the ThousandDollarDeposit from the firing of Rule 1, and generates the DepositedThousandDollarsThisMonth event. The following gets logged into TL:

[0443] 9: (1234, DepositedThousandDollarsThisMonth, Rule2, 7/5), (8), (1)—This is to be read as follows:

[0444] Rule2 accepts event 8 and generates the

[0445] DepositedThousandDollarsThisMonth event.

[0446] WRS contains:

[0447] RuleID: 2

[0448] IsActive: Yes

[0449] Counter: 2

[0450] TimeWindow: 7/1-7/31

[0451] MatchedEvents: 2

[0452] HasFired: Yes

[0453] NextState: Null

[0454] WES contains:

[0455] LocationID: 1

[0456] ReferenceCount: 0

[0457] LogLocation: 7

[0458] TimeStamp: 7/5

[0459] LocationID: 2

[0460] ReferenceCount: 1

[0461] LogLocation: 8

[0462] TimeStamp: 7/5

[0463] LocationID: 3

[0464] ReferenceCount: 0

[0465] LogLocation: 9

[0466] TimeStamp: 7/5

[0467] Rule3 accepts the DepositedThousandDollarsThisMonth event and, since the rule needs three things to fire, only partially arms the rule. The following gets logged into the TL:

[0468] 10: (1234, 0, Rule3, 7/5), (9,0,0), (0)—This is to be read as follows:

[0469] Rule3 accepts event 9 and arms itself. This is indicated in the following way:

[0470] 10: (1234, 0, Rule3, 7/5), (9,0,0), (0)—0 indicates that the rule itself does not fire.

[0471] 10: (1234, 0, Rule3, 7/5), (9,0,0), (0)—(9,0,0) indicates that this rule needs to capture three events in order to fire, and event 9 has been captured as the first of the three.

[0472] WRS contains:

[0473] RuleID: 2

[0474] IsActive: Yes

[0475] Counter: 2

[0476] TimeWindow: 7/1-7/31

[0477] MatchedEvents: 2

[0478] HasFired: Yes—Keep alive for inhibition

[0479] NextState: Null

[0480] RuleID: 3

[0481] IsActive: Yes

[0482] Counter: 0

[0483] TimeWindow: 7/5-10/5 (Once armed, has time window of 3 months)

[0484] MatchedEvents: 3

[0485] HasFired: No

[0486] NextState: Null

[0487] WES contains:

[0488] LocationID: 1

[0489] ReferenceCount: 0

[0490] LogLocation: 7

[0491] TimeStamp: 7/5

[0492] LocationID: 2

[0493] ReferenceCount: 1

[0494] LogLocation: 8

[0495] TimeStamp: 7/5

[0496] LocationID: 3

[0497] ReferenceCount: 1

[0498] LogLocation: 9

[0499] TimeStamp: 7/5

[0500] Building up the ESS from the WES, and the RSS from the WRS—the Rules State Section (RSS) is derived directly from the Working Rules State (VY'RS). The Event State Section (ESS) is derived from the Working Event State (WES) in the following fashion: Any event that has a reference count that is set to 0 no longer has to be saved, since no working rule refers to the event. Therefore, the WES event with LocationID 1 will be removed from the ESS.

[0501] RRS contains:

[0502] RuleID: 2

[0503] IsActive: Yes

[0504] Counter: 2

[0505] TimeWindow: 7/1-7/31

[0506] MatchedEvents: 2

[0507] HasFired: Yes—Keep alive for inhibition

[0508] NextState: Null

[0509] RuleID: 3

[0510] IsActive: Yes

[0511] Counter: 0

[0512] TimeWindow: 7/5-10/5 (Once armed, has time window of 3 months)

[0513] MatchedEvents: 3

[0514] HasFired: No

[0515] NextState: Null

[0516] ESS contains:

[0517] LocationID: 2

[0518] ReferenceCount: 1

[0519] LogLocation: 8

[0520] TimeStamp: 7/5

[0521] LocationID: 3

[0522] ReferenceCount: 1

[0523] LogLocation: 9

[0524] TimeStamp: 7/5

[0525] This ends the processing that occurred because of TN3. Time Event: On 8/1 the following occurs. Rule2, which was being kept alive by an inhibition in effect until 7/3 1, expires and is removed from the RSS. The removal of Rule2 brings down the reference count for the event with LocationID 2, decrements its reference count to 0, and forces it to be removed from the ESS. (Note that the removal of the state of Rule2 removes the inhibition that it was enforcing and paves the way for Rule2 to fire again.) These changes are reflected as follows:

[0526] RSS contains:

[0527] RuleID: 3

[0528] IsActive: Yes

[0529] Counter: 0

[0530] TimeWindow: 7/5-10/5 (Once armed, has time window of 3 months)

[0531] MatchedEvents: 3

[0532] HasFired: No

[0533] NextState: Null

[0534] ESS contains:

[0535] LocationID: 3

[0536] ReferenceCount: 1

[0537] LogLocation: 9

[0538] TimeStamp: 7/5

[0539] TN 4: On 8/5, the customer deposits over $1000 and the system responds in a way that continues to arm Rule3, which is looking to trigger when three deposits over $1000 occur across a period of three months. The WES and the WRS are restored and are identical to the RSS and ESS after the 8/1 time event.

[0540] WRS contains:

[0541] RuleID: 3

[0542] IsActive: Yes

[0543] Counter: 0

[0544] TimeWindow: 7/5-10/5 (Once armed, has time window of 3 months)

[0545] MatchedEvents: 3

[0546] HasFired: No

[0547] NextState: Null

[0548] WES contains:

[0549] LocationID: 3

[0550] ReferenceCount: 1

[0551] LogLocation: 9

[0552] TimeStamp: 7/5

[0553] The following logged events detail the workings that occur:

[0554] TN4 gets logged as follows:

[0555] 11: (1234, (Deposit, $1020), RT, 8/5), ( ), (1)—This is to be read as follows:

[0556] The original customer event of depositing $1020 is logged in location 11. This is an external event that starts the chain reaction of rule reaction and further events firing.

[0557] WRS contains:

[0558] RuleID: 3

[0559] IsActive: Yes

[0560] Counter: 0

[0561] TimeWindow: 7/5-10/5 (Once armed, has time window of 3 months)

[0562] MatchedEvents: 3

[0563] HasFired: No

[0564] NextState: Null

[0565] WES contains:

[0566] LocationID: 3

[0567] ReferenceCount: 1

[0568] LogLocation: 9

[0569] TimeStamp: 7/5

[0570] LocationID: 4

[0571] ReferenceCount: 0

[0572] LogLocation: 11

[0573] TimeStamp: 8/5

[0574] John Doe is over 21 years old, and Rule 1 transforms TN1 to the simple event ThousandDollarDeposit. The following gets logged into TL:

[0575] 12: (1234, ThousandDollarDeposit, Rule1, 8/5), (11), (1)—This is to be read as follows:

[0576] Rule1 accepts event 11 and generates the

[0577] ThousandDollarDeposit event.

[0578] WRS contains:

[0579] RuleID: 3

[0580] IsActive: Yes

[0581] Counter: 0

[0582] TimeWindow: 7/5-10/5 (Once armed, has time window of 3 months)

[0583] MatchedEvents: 3

[0584] HasFired: No

[0585] NextState: Null

[0586] WES contains:

[0587] LocationID: 3

[0588] ReferenceCount: 1

[0589] LogLocation: 9

[0590] TimeStamp: 7/5

[0591] LocationID: 4

[0592] ReferenceCount: 0

[0593] LogLocation: 11

[0594] TimeStamp: 8/5

[0595] LocationID: 2

[0596] ReferenceCount: 0 (No rules have yet armed on this event.)

[0597] LogLocation: 12

[0598] TimeStamp: 8/5

[0599] Rule2 accepts the ThousandDollarDeposit from the firing of Rule 1, and generates the DepositedThousandDollarsThisMonth event. The following gets logged into TL:

[0600] 13: (1234, DepositedThousandDollarsThisMonth, Rule2, 8/5), (12), (1)—This is to be read as follows:

[0601] Rule2 accepts event 12 and generates the

[0602] DepositedThousandDollarsThisMonth event.

[0603] WRS contains:

[0604] RuleID: 3

[0605] IsActive: Yes

[0606] Counter: 0

[0607] TimeWindow: 7/5-10/5 (Once armed, has time window of 3 months)

[0608] MatchedEvents: 3

[0609] HasFired: No

[0610] NextState: Null

[0611] RuleID: 2

[0612] IsActive: Yes

[0613] Counter: 2

[0614] TimeWindow: 8/1-8/31

[0615] MatchedEvents: 5

[0616] HasFired: Yes

[0617] NextState: Null

[0618] WES contains:

[0619] LocationID: 3

[0620] ReferenceCount: 1

[0621] LogLocation: 9

[0622] TimeStamp: 7/5

[0623] LocationID: 4

[0624] ReferenceCount: 0

[0625] LogLocation: 11

[0626] TimeStamp: 8/5

[0627] LocationID: 5

[0628] ReferenceCount: 1

[0629] LogLocation: 12

[0630] TimeStamp: 8/5

[0631] LocationID: 6

[0632] ReferenceCount: 0

[0633] LogLocation: 13

[0634] TimeStamp: 8/5

[0635] Rule3 accepts the DepositedThousandDollarsThisMonth event and arms the rule with the second of the three events that it requires. The following gets logged into TL:

[0636] 14: (1234, 0, Rule3, 8/5), (9,13,0), (0)—This is to be read as follows:

[0637] Rule3 accepts event 13 and arms itself. This is indicated in the following way:

[0638] 14: (1234, 0, Rule3, 8/5), (9,13,0), (0)—0 indicates that the rule itself does not fire.

[0639] 14: (1234, 0, Rule3, 8/5), (9,13,0), (0)—(9,13,0) indicates that this rule needs to capture three events in order to fire, and event 9 has been captured as one of those three.

[0640] WRS contains:

[0641] RuleID: 3

[0642] IsActive: Yes

[0643] Counter: 0

[0644] TimeWindow: 7/5-10/5 (Once armed, has time window of 3 months)

[0645] MatchedEvents: 3, 6

[0646] HasFired: No

[0647] NextState: Null

[0648] RuleID): 2

[0649] IsActive: Yes

[0650] Counter: 2

[0651] TimeWindow: 8/1-8/31

[0652] MatchedEvents: 5

[0653] HasFired: Yes

[0654] NextState: Null

[0655] WES contains:

[0656] LocationID: 3

[0657] ReferenceCount: 1

[0658] LogLocation: 9

[0659] TimeStamp: 7/5

[0660] LocationID: 4

[0661] ReferenceCount: 0

[0662] LogLocation: 11

[0663] TimeStamp: 8/5

[0664] LocationID: 5

[0665] ReferenceCount: 1

[0666] LogLocation: 12

[0667] TimeStamp: 8/5

[0668] LocationID: 6

[0669] ReferenceCount: 1

[0670] LogLocation: 13

[0671] TimeStamp: 8/5

[0672] Building up the ESS from the WES, and the RSS from the WRS—the Rules State Section (RSS) is derived directly from the Working Rules State (WRS). The Event State Section (ESS) is derived from the Working Event State (WES) in the following fashion: Any event that has a reference count that is set to 0 no longer has to be saved, since no working rule refers to the event. Therefore, the WES event with LocationID 4 will be removed from the ESS.

[0673] RSS contains:

[0674] RuleID: 3

[0675] IsActive: Yes

[0676] Counter: 0

[0677] TimeWindow: 7/5-10/5 (Once armed, has time window of 3 months)

[0678] MatchedEvents: 3, 6

[0679] HasFired: No

[0680] NextState: Null

[0681] RuleID: 2

[0682] IsActive: Yes

[0683] Counter: 2

[0684] TimeWindow: 8/1-8/31

[0685] MatchedEvents: 5

[0686] HasFired: Yes

[0687] NextState: Null

[0688] ESS contains:

[0689] LocationID: 3

[0690] ReferenceCount: 1

[0691] LogLocation: 9

[0692] TimeStamp: 7/5

[0693] LocationID: 5

[0694] ReferenceCount: 1

[0695] LogLocation: 12

[0696] TimeStamp: 8/5

[0697] LocationID: 6

[0698] ReferenceCount: 1

[0699] LogLocation: 13

[0700] TimeStamp: 8/5

[0701] This ends the processing that occurred because of TN4.

[0702] TN 5: On 8/25, the customer again deposits over $1000 in the month of August. Instead of being absorbed into the system, Rule2 rejects the deposit since the rule is configured to reject a second deposit once it has already accepted a $1000 deposit in a particular month. (This is referred to as the rule inhibition mechanism.)

[0703] The following logged events detail the workings that occur:

[0704] TN5 gets logged as follows:

[0705] 15: (1234, (Deposit, $1020), RT, 8/25, ( ), (1)—This is to be read as follows:

[0706] A deposit of $1020 was made on 8/25. The RT indicates that this is a “raw transaction” that was brought in by an external system. The “(1)” at the end indicates that the transaction was matched by a downstream rule.

[0707] WRS contains:

[0708] RuleID: 3

[0709] IsActive: Yes

[0710] Counter: 0

[0711] TimeWindow: 7/5-10/5 (Once armed, has time window of 3 months)

[0712] MatchedEvents: 3, 6

[0713] HasFired: No

[0714] NextState: Null

[0715] RuleID: 2

[0716] IsActive: Yes

[0717] Counter: 2

[0718] TimeWindow: 8/1-8/31

[0719] MatchedEvents: 5

[0720] HasFired: Yes

[0721] NextState: Null

[0722] WES contains:

[0723] LocationID: 3

[0724] ReferenceCount: 1

[0725] LogLocation: 9

[0726] TimeStamp: 7/5

[0727] LocationID: 5

[0728] ReferenceCount: 1

[0729] LogLocation: 12

[0730] TimeStamp: 8/5

[0731] LocationID: 6

[0732] ReferenceCount: 1

[0733] LogLocation: 13

[0734] TimeStamp: 8/5

[0735] LocationID: 7

[0736] ReferenceCount: 0

[0737] LogLocation: 15

[0738] TimeStamp: 8/25

[0739] John Doe is over 21 years old, and Rule 1 transforms TN1 to the simple event ThousandDollarDeposit. The following gets logged into TL:

[0740] 16: (1234, ThousandDollarDeposit, Rule1, 8/25), (15), (1)—This is to be read as follows:

[0741] Rule 1 accepts event 15 and generates a ThousandDollarDeposit event.

[0742] WRS contains:

[0743] RuleID: 3

[0744] IsActive: Yes

[0745] Counter: 0

[0746] TimeWindow: 7/5-10/5 (Once armed, has time window of 3 months)

[0747] MatchedEvents: 3, 6

[0748] HasFired: No

[0749] NextState: Null

[0750] RuleID: 2

[0751] IsActive: Yes

[0752] Counter: 2

[0753] TimeWindow: 8/1-8/31

[0754] MatchedEvents: 5

[0755] HasFired: Yes

[0756] NextState: Null

[0757] WES contains:

[0758] LocationID: 3

[0759] ReferenceCount: 1

[0760] LogLocation: 9

[0761] TimeStamp: 7/5

[0762] LocationID: 5

[0763] ReferenceCount: 1

[0764] LogLocation: 12

[0765] TimeStamp: 8/5

[0766] LocationID: 6

[0767] ReferenceCount: 1

[0768] LogLocation: 13

[0769] TimeStamp: 8/5

[0770] LocationID: 7

[0771] ReferenceCount: 0

[0772] LogLocation: 15

[0773] TimeStamp: 8/25

[0774] LocationID: 8

[0775] ReferenceCount: 0

[0776] LogLocation: 16

[0777] TimeStamp: 8/25

[0778] Rule2 rejects the ThousandDollarDeposit from the firing of Rule 1, since the rule is configured to inhibit arming once the rule has already fired. (That earlier firing occurred because of TN4 on 8/5.) The following gets logged into TL:

[0779] 17: (1234, 0, Rule2, 8/5), (16), (0)—This is to be read as follows:

[0780] Rule2 rejected event 16.

[0781] The WES and the WRS look identical to the previous WES and WRS.

[0782] Building up the ESS from the WES, and the RSS from the WRS—the Rules State Section (RSS) is derived directly from the Working Rules State (WRS). The Event State Section (ESS) is derived from the Working Event State (WES) in the following fashion: Any event that has a reference count that is set to 0 no longer has to be saved, since no working rule refers to the event. Therefore, the WES events with LocationID 7 and LocationID 8 are removed from the ESS. (This is all intuitive, since TN5 is rejected, the ESS and RSS look identical to the way they looked on 8/5.)

[0783] RSS contains:

[0784] RuleID: 3

[0785] IsActive: Yes

[0786] Counter: 0

[0787] TimeWindow: 7/5-10/5 (Once armed, has time window of 3 months)

[0788] MatchedEvents: 3, 6

[0789] HasFired: No

[0790] NextState: Null

[0791] RuleID: 2

[0792] IsActive: Yes

[0793] Counter: 2

[0794] TimeWindow: 8/1-8/31

[0795] MatchedEvents: 5

[0796] HasFired: Yes

[0797] NextState: Null

[0798] ESS contains:

[0799] LocationID: 3

[0800] ReferenceCount: 1

[0801] LogLocation: 9

[0802] TimeStamp: 7/5

[0803] LocationID: 5

[0804] ReferenceCount: 1

[0805] LogLocation: 12

[0806] TimeStamp: 8/5

[0807] LocationID: 6

[0808] ReferenceCount: 1

[0809] LogLocation: 13

[0810] TimeStamp: 8/5

[0811] Time Event: On 9/1 the following occurs.Rule2, which was being kept alive by an inhibition in effect until 9/3 1, expires and is removed from the RSS. The removal of Rule2 brings down the reference count for the event with LocationID 2, decrements its reference count to 0, and forces it to be removed from the ESS. (Note that the removal of the state of Rule2 removes the inhibition that it was enforcing and paves the way for Rule2 to fire again.) These changes are reflected as follows:

[0812] RSS contains:

[0813] RuleID: 3

[0814] IsActive: Yes

[0815] Counter: 0

[0816] TimeWindow: 7/5-10/5 (Once armed, has time window of 3 months)

[0817] MatchedEvents: 3, 6

[0818] HasFired: No

[0819] NextState: Null

[0820] ESS contains:

[0821] LocationID: 3

[0822] ReferenceCount: 1

[0823] LogLocation: 9

[0824] TimeStamp: 7/5

[0825] LocationID: 6

[0826] ReferenceCount: 1

[0827] LogLocation: 13

[0828] TimeStamp: 8/5

[0829] TN 6: On 9/5, the customer finally deposits the over $1000 amount that completes the three months of over $1000 deposits and triggers the “Good Customer” behavior.

[0830] The following logged events detail the workings that occur:

[0831] TN6 gets logged as follows:

[0832] 18: (1234, (Deposit, $1020), RT, 9/5, ( ), (1)—This is to be read as follows:

[0833] The original customer event of depositing $1020 is logged in location 18. This is an external event that starts the chain reaction of rule reaction and further events. The RT indicates that this event was logged because of a raw transaction, and that no rule fired in order to generate this event.

[0834] The WRS and the WES have the event and rule state associated with RuleID2 removed since Rule2 has exceeded the 8/31 time limit.

[0835] WRS contains:

[0836] RuleID: 3

[0837] IsActive: Yes

[0838] Counter: 0

[0839] TimeWindow: 7/5-10/5 (Once armed, has time window of 3 months)

[0840] MatchedEvents: 3, 6

[0841] HasFired: No

[0842] NextState: Null

[0843] WES contains:

[0844] LocationID: 3

[0845] ReferenceCount: 1

[0846] LogLocation: 9

[0847] TimeStamp: 7/5

[0848] LocationID: 6

[0849] ReferenceCount: 1

[0850] LogLocation: 13

[0851] TimeStamp: 8/5

[0852] LocationID: 7

[0853] ReferenceCount: 0

[0854] LogLocation: 18

[0855] TimeStamp: 9/5

[0856] John Doe is over 21 years old, and Rule 1 transforms TN1 to the simple event ThousandDollarDeposit. The following gets logged into TL:

[0857] 19: (1234, ThousandDollarDeposit, Rule1, 9/5), (1), (1)—This is to be read as follows:

[0858] Rule 1 accepts event 18 and generates a ThousandDollarDeposit event.

[0859] WRS contains:

[0860] RuleID: 3

[0861] IsActive: Yes

[0862] Counter: 0

[0863] TimeWindow: 7/5-10/5 (Once armed, has time window of 3 months)

[0864] MatchedEvents: 3, 6

[0865] HasFired: No

[0866] NextState: Null

[0867] WES contains:

[0868] LocationID: 3

[0869] ReferenceCount: 1

[0870] LogLocation: 9

[0871] TimeStamp: 7/5

[0872] LocationID: 6

[0873] ReferenceCount: 1

[0874] LogLocation: 13

[0875] TimeStamp: 8/5

[0876] LocationID: 7

[0877] ReferenceCount: 0

[0878] LogLocation: 18

[0879] TimeStamp: 9/5

[0880] LocationID: 8

[0881] ReferenceCount: 0

[0882] LogLocation: 19

[0883] TimeStamp: 9/5

[0884] Rule2 accepts the ThousandDollarDeposit from the firing of Rule 1, and generates the DepositedThousandDollarsThisMonth event. The following gets logged into TL:

[0885] 20: (1234, DepositedThousandDollarsThisMonth, Rule2, 9/5), (19), (1)—This is to be read as follows:

[0886] Rule2 accepts event 8 and generates the

[0887] DepositedThousandDollarsThisMonth event.

[0888] WRS contains:

[0889] RuleID: 3

[0890] IsActive: Yes

[0891] Counter: 0

[0892] TimeWindow: 7/5-10/5 (Once armed, has time window of 3 months)

[0893] MatchedEvents: 3, 6

[0894] HasFired: No

[0895] NextState: Null

[0896] RuleID: 2

[0897] IsActive: Yes

[0898] Counter: 2

[0899] TimeWindow: 9/1-9/30

[0900] MatchedEvents: 5

[0901] HasFired: Yes

[0902] NextState: Null

[0903] WES contains:

[0904] LocationID: 3

[0905] ReferenceCount: 1

[0906] LogLocation: 9

[0907] TimeStamp: 7/5

[0908] LocationID: 6

[0909] ReferenceCount: 1

[0910] LogLocation: 13

[0911] TimeStamp: 8/5

[0912] LocationID: 7

[0913] ReferenceCount: 0

[0914] LogLocation: 18

[0915] TimeStamp: 9/5

[0916] LocationID: 8

[0917] ReferenceCount: 1

[0918] LogLocation: 19

[0919] TimeStamp: 9/5

[0920] LocationID: 9

[0921] ReferenceCount: 0

[0922] LogLocation: 20

[0923] TimeStamp: 9/5

[0924] Rule3 accepts the DepositedThousandDollarsThisMonth event and fires, since it now has the three events that it needed. The following gets logged into the TL:

[0925] 21: (1234, DepositedThousandDollarsOverThreeMonths, Rule3, 9/5), (9,13,20), (1)—This is to be read as follows:

[0926] Rule 3 completes its preconditions, having received events 9, 13, and 20, and fires event

[0927] DepositedThousandDollarsOverThreeMonths. The final “(1)” indicates that the event is matched in some downstream rule.

[0928] WRS contains:

[0929] RuleID: 3

[0930] IsActive: Yes

[0931] Counter: 0

[0932] TimeWindow: 7/5-10/5 (Once armed, has time window of 3 months)

[0933] MatchedEvents: 3, 6, 9

[0934] HasFired: Yes

[0935] NextState: Null

[0936] *** This rule fires, removes itself from the WRS, and decrements the reference count of events 3, 6, and 9.

[0937] RuleID: 2

[0938] IsActive: Yes

[0939] Counter: 2

[0940] TimeWindow: 9/1-9/30

[0941] MatchedEvents: 5

[0942] HasFired: Yes

[0943] NextState: Null

[0944] WES contains:

[0945] LocationID: 3

[0946] ReferenceCount: 0

[0947] LogLocation: 9

[0948] TimeStamp: 7/5

[0949] LocationID: 6

[0950] ReferenceCount: 0

[0951] LogLocation: 13

[0952] TimeStamp: 8/5

[0953] LocationID: 7

[0954] ReferenceCount: 0

[0955] LogLocation: 18

[0956] TimeStamp: 9/5

[0957] LocationID: 8

[0958] ReferenceCount: 1

[0959] LogLocation: 19

[0960] TimeStamp: 9/5

[0961] LocationID: 9

[0962] ReferenceCount: 0

[0963] LogLocation: 20

[0964] TimeStamp: 9/5

[0965] LocationID: 10

[0966] ReferenceCount: 0

[0967] LogLocation: 21

[0968] TimeStamp: 9/5

[0969] Rule4 accepts the DepositedThousandDollarsOverThreeMonths event, and generates the “Good Customer” trigger. The event is logged as follows:

[0970] 22: (1234, “<Trigger>

[0971] <Customer>1234</Customer>

[0972] <Date>9/5</Date>

[0973] <Triggered>GoodCustomer</Triggered>

[0974] </Trigger>”, Rule4, 9/5), (2 1), (0)—This is to be read as follows:

[0975] Rule4 accepts event 21 and generates the “Good Customer” trigger. The “<Trigger>” xml structure is output to a trigger table.

[0976] Since Rule4 does not hold any state, it does not get recorded in the WRS and it does not increment the reference count of any of the events. The WRS and the WES are identical to how they were after Rule3 fired

[0977] WRS contains:

[0978] RuleID: 2

[0979] IsActive: Yes

[0980] Counter: 2

[0981] TimeWindow: 9/1-9/30

[0982] MatchedEvents: 5

[0983] HasFired: Yes

[0984] NextState: Null

[0985] WES contains:

[0986] LocationID: 3

[0987] ReferenceCount: 0

[0988] LogLocation: 9

[0989] TimeStamp: 7/5

[0990] LocationID: 6

[0991] ReferenceCount: 0

[0992] LogLocation: 13

[0993] TimeStamp: 8/5

[0994] LocationID: 7

[0995] ReferenceCount: 0

[0996] LogLocation: 18

[0997] TimeStamp: 9/5

[0998] LocationID: 8

[0999] ReferenceCount: 1

[1000] LogLocation: 19

[1001] TimeStamp: 9/5

[1002] LocationID: 9

[1003] ReferenceCount: 0

[1004] LogLocation: 20

[1005] TimeStamp: 9/5

[1006] LocationID: 10

[1007] ReferenceCount: 0

[1008] LogLocation: 21

[1009] TimeStamp: 9/5

[1010] Building up the ESS from the WES, and the RSS from the WRS—the Rules State Section (RSS) is derived directly from the Working Rules State (WRS). The Event State Section (ESS) is derived from the Working Event State (WES) in the following fashion: Any event that has a reference count that is set to 0 no longer has to be saved, since no working rule refers to the event. Therefore, the WES events with LocationIDs=3, 6, 7, 9, and 10 will be removed from the ESS.

[1011] RSS contains:

[1012] RuleID: 2

[1013] IsActive: Yes

[1014] Counter: 2

[1015] TimeWindow: 9/1-9/30

[1016] MatchedEvents: 5

[1017] HasFired: Yes

[1018] NextState: Null

[1019] ESS contains:

[1020] LocationID: 8

[1021] ReferenceCount: 1

[1022] LogLocation: 19

[1023] TimeStamp: 9/5

[1024] At the end of September, the time window will expire for Rule 2 and the RSS and the ESS will return to null, This is as expected: the “Good Customer” trigger fires, the rule sets have performed their required task of identifying 3 successive months of deposits greater than $1000, and the state of the RSS and ESS returns back to null.

[1025] Although the invention has been described and pictured in a preferred form with a certain degree of particularity, it is understood that the present disclosure of the preferred form, has been made only by way of example, and that numerous changes in the details of construction and combination and arrangement of parts may be made without departing from the spirit and scope of the invention as hereinafter claimed. For example, although financial transactions are described in the working example, any type of activity that an entity wishes to monitor is envisioned. It is intended that the patent shall cover by suitable expression in the appended claims, whatever features of patentable novelty exist in the invention disclosed.