# Patent

## Title
Hybrid database architecture for both maintaining and relaxing type 2 data entity behavior

## Abstract

A database schema architecture and operators therefor is disclosed for storing data providing information about membership of items in one or more groups, wherein when such a group is a simulated group, access to group item data related to activities of the group items prior to creation of the simulated group is provided. When such a group is an actual group, access to group item data related to activities of the group items prior to creation of the group is constrained such that group entities have database Type 2 behavior. The architecture provides a common schema for both actual and simulated groups. The architecture provides the ability to create simulated or hypothesized groups of agents in a contact center, wherein the groups can be evaluated using agents' past performance. Such groups are represented by the same schemas as actual groups, and the data entities for the actual groups exhibit Type 2 database behavior.

## Background
RELATED FIELD OF THE INVENTION
The present invention relates to database architecture for retaining information about the grouping of items (e.g., contact center agents) so that from a data entity for a simulated group, access to historical information about activities related to items of the group prior to group creation are readily accessible, and from a data entity for an actual group, access to such historical information is restricted.
BACKGROUND
Various constraint types have been defined for database entities. In particular, data entities may be identified as either Type 1 or Type 2, wherein Type 1 data entities model items or objects in a way that precludes access constraints to information indicative of any changes to the modeled items or objects over time, and wherein Type 2 data entities model items or objects in a way that permits such access constraints to be enforced. For example, for agents of a contact center wherein each agent may be assigned to multiple agent groups concurrently, and may be assigned to or removed from various agent groups over time, data entities for modeling membership of agents in groups is typically modeled as Type 2 so that time-based constraints related to group membership are maintained. In particular, for each database group data entity that models a contact center group, such a typical time-based constraint would be: for each contact center group G, associate the entities in a contact center database so that from a group data entity modeling the group G, the only agent performance data available for access is the agent performance data for each time period that each agent was/is a member of the group G.
Although such Type 2 database schema constraints are generally appropriate and desired, there are circumstances when such constraints preclude easy implementation of certain operations such as simulations of groups. For example, to simulate the performance of a proposed agent group, access would be typically required to at least some (if not most) agent performance data for agents proposed to be members of the simulated group. However, such Type 2 database constraints as described above, prevents access to such historical agent performance data if the simulated group is modeled by a group data entity (and an associated membership data entity) which conforms to such Type 2 constraints. Accordingly, the alternative would be to implement an entire new schema for simulated groups. However, then such simulated groups could not be easily converted to actual groups without re-entering the group information. Moreover, extra effort would be required if it is desired to associate the simulated group information with the actual group so that, e.g., subsequent actual group performance can be compared to the simulated group performance.
Accordingly, it is desirable to have a method and database schema architecture that allows simulated groups as described hereinabove to be implemented with a database schema architecture together with operations that allow both Type 2 constraints for actual groups, and additionally allow simulated groups to be provided, wherein for members of a simulated group, substantially all agent performance data prior to the creation of the simulated group is available to be accessed via a data entity for the simulated group.
TERMS AND DEFINITIONS


    Data entity: A collection of data that is logically associated together. In a relational database a data entity can be a row of a table or an entire table.
    Database entity type: A schema or definition for organizing data in a database. Such schemas may be specified in SQL or another database related language.
    Natural key: An identifier that uniquely identifies a data entity (e.g., a table row) representing a corresponding real world object or action, and through which access is provided to all data identified with the object or action.
    Agent surrogate key: A database identifier that is used to associate two data entities (e.g., rows). In particular, surrogate keys need not conform to a data format dictated by data formats external to the database. Accordingly, the use of surrogate keys can prevent wide spread changes to the database if the data content or type for a corresponding natural key changes (as one skilled in the art will appreciate). In the present disclosure, an agent surrogate key identifies a “version” of the agent, wherein the version of the agent is for a specific range of time.
    Type 2: Database constraints related to the tracking and accessing of changes or versions of database entities (e.g., tables and entries thereof) through time, wherein such constraints prevent access to certain instances (or versions) of such entities that are outside of a predetermined time period. For example, if data for agent groups is modeled as Type 2, for an agent A that becomes a member of an agent group G at a particular time T, access (via the data model for group G) to data identifying activities performed by agent A would be restricted to only the time while agent A is a member of the group G. Thus, data identifying activities performed by agent A prior to time T would not be accessible via the data model for the group G.


SUMMARY
A database entity schema architecture and operators therefor is disclosed for storing data providing information about membership of items in one or more groups, wherein when such a group is a simulated group, the architecture and operators therefor provide access to group item data related to activities of the group items prior to creation of the simulated group. In particular, even though the fundamental data architecture for groups (and other data entities) may be Type 2 (as this term is described in the Terms and Definitions sections hereinabove), the database entity schema architecture and operators disclosed herein provide for data access and management of information for simulated groups, wherein data related to activities of the group items (e.g., agents), e.g., prior to creation of the simulated group is accessible via the data model for the simulated group. However, when such a group is an actual group, the architecture and operators therefor constrain access to group item data related to activities of the group items prior to creation of the group such that group entities have database Type 2 behavior. The architecture provides a common entity schema for both actual and simulated groups. The architecture is particularly useful for providing the ability to create simulated or hypothesized groups of agents in a contact center, wherein the groups can be evaluated using past performance of the agents. However, such groups are represented by the same data schemas as actual groups, and the data entities for the actual groups exhibit Type 2 database behavior.
Said another way, the database method and data architecture disclosed herein provides Type 2 database constraints related to the tracking and accessing of changes or versions of database entities (e.g., tables and entries thereof) through time while allowing certain instances of such entities to be created whereby such Type 2 constraints are relaxed. In particular, for certain group data entities, such Type 2 constraints are relaxed. That is; for an instance of such a group data entity, there is a relaxation of a Type 2 constraint that typically prevents access to data for evaluating the group items, wherein this data is for activities performed prior to the creation of the group. More particularly, the present disclosure is directed to providing a capability for incorporating data representing a simulated group into a group entity data schema whose instances also represent actual groups, wherein data for such a simulated group can be used to access historical data for items of the simulated group independently of the time of creation of the simulated group. In one especially important embodiment disclosed herein, the simulated groups are groups of agents for a contact center, wherein for each simulated group, the performance data of the agents for the simulated group is accessible via database keys for the simulated group wherein the performance data relates to agent tasks performed well before creation of the simulated group. Thus, for a simulated agent group, performance data for agents of the group from, e.g., 6 months or longer, prior to the creation of the simulated group is accessible via one or more database keys for the simulated group so that an agent performance simulation program can readily access such agent data.
Moreover, the present disclosure also allows such simulated groups to be readily converted to actual groups that then conform to the Type 2 database constraints for groups described hereinabove.
Additionally, in at least one embodiment, the method and data architecture herein allows a report generator for producing reports on the performance of actual agent group of a contact center agent to also generate correspondingly formatted reports for such simulated groups. In particular, a database entity architecture used by legacy report generators for accessing agent performance data via group data entities can be converted according to the method and data architecture disclosed herein so that such a legacy report generator can print similar reports on simulated groups.
In one embodiment the method and data architecture disclosed herein is for simulating a group of one or more agents, wherein the following steps (A) through (C) are performed:

    
    
        (A) providing access to at least a first instance of a predetermined group data entity type, wherein each instance of the group data entity type corresponds to a group of one or more agents, and each instance provides access to:
        
            (a-1) at least one key for identifying the corresponding group,
            (a-2) a timestamp field having a time value identifying an earliest date for accessing data indicative of a performance of agents in the corresponding group;
            (a-3) a group type field having a value identifying the corresponding group as one of:
            
                (i) an actual group of agents, wherein performance data (PD1) for the agents of the actual group is associated with the instance for determining an actual performance of the corresponding group, and wherein the performance data PD1 corresponds to agent tasks performed substantially no earlier than a creation of the actual group, and
                (ii) a simulated group of agents, wherein performance data (PD2) for the agents of the simulated group is associated with the instance for determining a performance of the simulated group, and wherein the performance data PD2 corresponds to agent tasks performed from a time sufficiently prior to a creation of the simulated group so that the time is at least as early as the earliest agent data that is desired to be accessed to prior to the creation of the corresponding group;
            
            
            wherein the first instance provides access to a first value according to (a-3)(i) indicating that the corresponding group (G1) for the first instance is an actual group, and the timestamp field for the first instance includes a time value related to the creation of G1;
        
        
        (B) creating a second instance of the group data entity type, wherein the second instance provides access to a second value according to (a-3)(ii) indicating that the corresponding group (G2) for the second instance is a simulated group, and the timestamp field for the second instance includes a time value (T) sufficiently prior to the creation of G2 so that the time value T is at least as early as the earliest agent performance data that is desired to be accessed to prior to the creation of G2; and
        (C) determining a performance measurement of the corresponding group G2 for the second instance, wherein for one or more agents of G2, corresponding agent performance data prior to creation of G2 is used.

In a more general context, the method and data architecture disclosed herein provides a method for simulating a group, including the steps (D) through (G) following:

        (D) providing a predetermined group database entity type wherein each instance of the group database entity type includes:
        
            (d-1) an identification storage area for identifying a corresponding group of items, and
            (d-2) a group type storage area for identifying the corresponding group as one of:
            
                (i) an actual group of one or more items, and
                (ii) a simulated group of one or more items;
                wherein the predetermined group database entity type defines a substantially entire data organization for each instance of the group database entity type within a data repository;
            
            
        
        
        (E) providing access to at least a first instance of the predetermined group database entity type using a value in the identification storage area of the first instance, wherein a value for the group type storage area identifies the first instance as corresponding to an actual group (G1) of one or more items;
        
            wherein for evaluating a performance of the first instance, item performance data (ED1) associated with the items of the actual group G1 is accessed according to Type 2 constraints for accessing ED1, wherein the item performance data ED1 is substantially for a time period no earlier than a creation of the actual group G1;
        
        
        (F) creating a second instance of the predetermined group data entity type, wherein the second instance corresponds to a simulated group (G2) of one or more items;
        
            wherein the step of creating includes storing a predetermined time value for determining, for the items of G2, the earliest date for item performance data that is desired for simulating an evaluation of G2, wherein the predetermined time value is substantially prior to the creation of G2;
        
        
        (H) evaluating a performance of the simulated group G2, wherein item performance data (ED2) associated with the items of the simulated group G2 is accessed for determining the second evaluation;
        
            wherein the accessing of the item performance data ED2 is determined using the predetermined time value.
        
        
    
    


Other features and benefits of the method and data architecture disclosed herein are described and/or shown in the accompanying figures together with the description hereinbelow.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 is a time line showing the creation, deletion and modification of contact center agent groups.
FIG. 2 shows representations of data entities for a first embodiment of the data architecture disclosed herein, wherein the data entities of this figure correspond to time T1 on the time line of FIG. 1.
FIG. 3A shows a representation of a group membership entity 40 according to a first embodiment of the method and data architecture disclosed herein, wherein the group membership entity 40 correspond to time T1 on the time line of FIG. 1.
FIG. 3B shows a representation of a group membership entity 40 according to the first embodiment of the method and data architecture disclosed herein, wherein the group membership entity 40 correspond to time T2 on the time line of FIG. 1.
FIG. 3C shows a representation of a group membership entity 40 according to the first embodiment of the method and data architecture disclosed herein, wherein the group membership entity 40 correspond to time T3 on the time line of FIG. 1.
FIG. 3D shows a representation of a group membership entity 40 according to the first embodiment of the method and data architecture disclosed herein, wherein the group membership entity 40 correspond to time T4 on the time line of FIG. 1.
FIG. 4A shows a representation of a group membership entity 150 together with modified and new agent data entities 20 according to a second embodiment of the method and data architecture disclosed herein, wherein the group membership entity 150 corresponds to time T1 on the time line of FIG. 1.
FIG. 4B shows a representation of a group membership entity 150 together with modified and new agent data entities 20 according to the second embodiment of the method and data architecture disclosed herein, wherein the group membership entity 150 corresponds to time T2 on the time line of FIG. 1.
FIG. 4C shows a representation of a group membership entity 150 according to the second embodiment of the method and data architecture disclosed herein, wherein the group membership entity 150 correspond to time T3 on the time line of FIG. 1.
FIG. 4D shows a representation of a group membership entity 150 according to the first embodiment of the method and data architecture disclosed herein, wherein the group membership entity 150 correspond to time T4 on the time line of FIG. 1.
FIG. 5 shows a representation of a flowchart of the steps performed when creating a simulated group according to the first embodiment of the method and data architecture herein.
FIG. 6 shows a representation of a flowchart of the steps performed when a simulated group is converted to an actual group according to the first embodiment of the method and data architecture herein.
FIG. 7 shows a representation of a flowchart of the steps performed when a simulated group is modified according to the first embodiment of the method and data architecture herein.
FIG. 8 shows a representation of a flowchart of the steps performed when a simulated group is deleted according to the first embodiment of the method and data architecture herein.
FIG. 9 shows a representation of a flowchart of the steps performed when creating a simulated group according to the second embodiment of the method and data architecture herein.
FIG. 10 shows a representation of a flowchart of the steps performed when a simulated group is converted to an actual group according to the second embodiment of the method and data architecture herein.
FIG. 11 shows a representation of a flowchart of the steps performed when a simulated group is modified according to the second embodiment of the method and data architecture herein.
FIG. 12 shows a representation of a flowchart of the steps performed when a simulated group is deleted according to the second embodiment of the method and data architecture herein.



DETAILED DESCRIPTION
FIG. 1 shows a time line of the relevant history of agents A, B, C, and D being added and deleted from various agent groups, and subsequently two trial groups (3 and 4) being created to simulate a performance of each of the trial groups according to the past performance of the agents in any of the groups 1 and 2. In particular, the time line prior to T1 indicates that (i) agent A was initially added to group 2 (Jan. 15, 2004), (ii) agent B was added to group 1 (Mar. 1, 2004), (iii) agent C was initially added to group 2 (Dec. 2, 2004) and then deleted from group 2 (Feb. 28, 2005), and (iv) agent D was added to both group 1 and 2, and then deleted from group 2 (May 2, 2005). Immediately after time T1 (Jul. 1, 2005) a contact center manager or supervisor (“user” herein) creates trial group 3 having agents A and B, and trial group 4 having agents C and D, wherein each of the trial groups provides access to all agent performance data (e.g., contact center tasks completed) from any predetermined date in the past (e.g., Jan. 1, 2000). Subsequently, trial group 3 is converted to an actual group (Jul. 9, 2005), followed by trial group 4 being deleted (Jul. 10, 2005).
FIG. 2 shows a simplified representation of some of the data entities included in a database for retaining contact center information at time T1. In particular, FIG. 2 shows data entities stored in such a database for identifying:

    
    
        (1.i) agents (e.g., the agent data entities 20, labeled individually as 20-1 through 20-4) providing access to data specific to each of the agents A-D; note that in one preferred embodiment, each of the agent data entities 20 is an entry or row in a relational database table, or more generally, an instance of a predetermined database data type;
        (1.ii) agent groups (e.g., the group data entities 28, labeled individually as 28-1 through 28-5); note that in one preferred embodiment, each of the group data entities 28 is an entry or row in a relational database table, or more generally, an instance of a predetermined database data type; and
        (1.iii) archived agent performance data (e.g., the agent task data entity 34) which in the present embodiment provides, a data entity or row for each task (of a predetermined set of tasks) performed by an agent. In particular, each such entity (also referred to as an “agent task data” entity) includes a timestamp indicating when the agent task was performed, a surrogate key for identifying the agent that performed the task, and an identification of the task performed (in the column headed “TASK DATA”); note that in one preferred embodiment, each of the agent task data entities may correspond to a row in a relational database table, or more generally, an instance of a predetermined database data type.
    
    


Regarding the agent data entities 20, each such entity (E) includes:

    
    
        (2.i) A natural key (denoted “AGENT_NATURAL_KEY” in the data entities 20-1 through 20-4) that is used to uniquely identify a corresponding agent (e.g., such a natural key provides data that uniquely provides access to all data identified with the agent). For simplicity of description, the natural key is AK(A) for agent A, AK(B) for agent B, and AK(C) for agent C. Thus, the data entity 20-1 for agent A has the value “AK(A)” as the value of the agent's natural key. However, it is within the scope of the present disclosure that various data representations can be used for such values, as one skilled in art will understand.
        (2.ii) A surrogate key (denoted “AGENT_SURROGATE_KEY” in the data entities 20-1 through 20-4) that is used to associate at least a portion of the data for the agent identified by the entity E. In particular, each such surrogate key can be used to identify one or more entities (e.g., also denoted “entries” herein) in the agent task data entity 34 (FIG. 2), wherein each of the entries in the agent task data entity 34 provides information about a contact center task that an agent (identified in the corresponding agent data entity 20) has performed. Thus, each instance of the AGENT_SURROGATE_KEY field (in an agent data entity 20) can be used to identify zero, one, or more entries in the agent task data entity 34.
    
    


For simplicity of description, the surrogate keys have the following format: xSK, where “x” is replaced with “A” for agent A, “B” for agent B, “C” for agent C, and “D” for agent D. Moreover, for each agent, there is exactly one AGENT_SURROGATE_KEY value that can be used for accessing the data describing a particular task performed by the agent (i.e., this data being in a corresponding entry in the agent task data entity 34 described hereinbelow). Thus, for agent D, agent data entity 20-4 has an AGENT_SURROGATE_KEY OF “DSK1”, which identifies all agent D entries in the agent task data entity 34 having data describing the (any) task(s) performed by agent D during the time period starting at Jan. 1, 2005 (this date identified by the “START_DATE” field of agent data entity 20-4).

    
    
        (2.iii) A start date field (denoted “START DATE” in the data entities 20-1 through 20-4), wherein the “START DATE” field identifies the starting date upon which the corresponding surrogate key identifies entries in the agent task data entity 34 that were performed on or after this date. Note that in some embodiments, each agent data entity 20 may also include an “END DATE” field for identifying, e.g., the ending date through which the corresponding surrogate key identifies entries in the agent task data entity 34 that were performed before or on this ending date.
    
    


Regarding the agent group data entities 28, each such entity includes:

    
    
        (3.i) A natural key (denoted “GROUP_NATURAL_KEY” in the data entities 28-1 through 28-5) that is used to identify an agent group (e.g., such a natural key provides data that uniquely provides access to all data identified with the agent group). For simplicity of description, the natural key is GK(1) for group 1, GK(2) for group 2, GK(3) for group 3, GK(4) for group 4, and GK(5) for group 5. Thus, the group data entity 28-1 for group 1 has the value “GK(1)” as the value of the group's natural key. However, it is within the scope of the present disclosure that various data representations can be used for such natural keys, as one skilled in art will understand.
        (3.ii) A surrogate key (denoted “GROUP_SURROGATE_KEY” in the data entities 28-1 through 28-5) that is also used to uniquely identify a group data entity 28 as one skilled in the art will understand. For simplicity of description, the surrogate keys have the following format: GxSKi, wherein:
        
            “x” is replaced with “1” for group 1, “2” for group 2, “3” for group 3 and “4” for group 4, and “5” for group 5, and
            “i” is replaced with an integer identifying the next (first) group data entity 28 associated with the group. Each next value for “i” represents a subsequent time period in which a corresponding modified version of the group data entity 28 describes the group during the time period identified by at least the “START_DATE” field (and by the “END_DATE” field as well if this field is filled-in).
        
        
        Thus, for group 1, group data entity 28-1 has a GROUP_SURROGATE_KEY OF “G1SK1”, which identifies the group 1 descriptor information applicable during the time period of Jan. 1, 2005 through Mar. 31, 2005 (these dates identified by the “START_DATE” and “END_DATE” fields of group 1 data entity 28-1). Additionally, the group data entity 28-2 for group 1 has a GROUP_SURROGATE_KEY OF “G1SK2”, which identifies the group 1 descriptor information applicable during the time period of Mar. 2, 2005 through a present date. Note, however, that it is within the scope of the present disclosure that various data representations can be used for values of the GROUP_SURROGATE_KEY, as one skilled in art will understand.
        (3.iii) Start and end data fields (respectively denoted “START DATE” and “END DATE” in the data entities 28-1 through 28-5), wherein for each group data entity, its “START DATE” field identifies the starting date upon which the group data entity is applicable and its “END DATE” field identifies the ending date upon which the group data entity is not longer applicable. Thus, e.g., group data entity 28-1 is applicable to group 1 until the group's supervisor changed on Apr. 1, 2004 (FIG. 1), and following such change, group data entity 28-2 became the applicable data describing group 1. Note that in the present embodiment an agent change to a group does not cause a new version of a group's data entity 28 to be generated. However, it is within the scope of the present disclosure that versioning of a group data entity 28 could be dependent upon agent changes to the corresponding group as one skilled in the art will understand.
        (3.iv) A trial group tag (represented by the “TRIAL_GROUP” field) whose value identifies whether the corresponding group is a trial (i.e., simulated) group, or an actual group.
        (3.v) One or more fields for describing the group, such as an identification of the group's supervisor, the group's location, the type of tasks handled by agents of the group.
    
    


Note that the data organization or model for group entities typically constrains such group entities to be Type 2 database entities. In particular, for actual groups, it is generally considered beneficial that their corresponding group entities be restricted from accessing agent performance data that is outside of the time range that the agent is a member of the group since such a restriction reduces the likelihood of a group evaluation process erroneously using agent performance data that does not coincide with member in the group. However, in the data architecture and method disclosed herein, such Type 2 restrictions may be dependent upon whether such a group entity is designated as an actual group or a simulated group. That is, actual groups may be Type 2 when determining group performances, and simulated groups are not Type 2 when simulating group likely performances.
Regarding the agent task data entity 34, for each row of this entity there are the following fields:

    
    
        (4.i) An agent surrogate key identifying an agent.
        (4.ii) One or more fields identifying a task performed by the agent corresponding to the agent surrogate key of (4.i).
        (4.iii) A timestamp field (denoted “TIMESTAMP”) for identifying the date and time that the task identified in (4.ii) was performed by the agent identified by the surrogate key of (4.i). Note that for simplicity the “TIMESTAMP” fields only show the date. Thus, for the first entry in the agent task data entity 34, the value “011504” represents the date Jan. 15, 2004.
        In addition to the data entities illustrated in FIG. 2, information must be retained for identifying the membership of agents in groups. In particular, for each group, the agents in the group and the time the agent is in the group needs to be captured. FIG. 3A shows a first embodiment 40 of such a membership data entity for retaining information about agent membership in groups. In particular, the membership entity 40 of FIG. 3A is representative of, e.g., the time T1 (FIG. 1). The membership entity 40 includes a plurality of associated fields (each such association represented here as a row in the membership entity 40), wherein each row includes the following fields:
        (5.i) A membership key (denoted “MEMBERSHIP KEY”) uniquely identifying the row.
        (5.ii) An agent key (denoted “AGENT KEY”) that uniquely identifies an agent. Note that in the present embodiment, the agent key is the natural key for the agent.
        (5.iii) A group key (denoted “GROUP KEY”) that uniquely identifies a group in which the agent is a member. Note that in the present embodiment group natural keys are used for identifying the group in which the agent identified in (5.ii) is a member. However, it is within the scope of the present disclosure for group surrogate keys to be used instead, as one skilled in the art will understand.
        (5.iv) A date and time stamp (denoted “START DATE”) for retaining the date and time that the agent was added to the group identified in (5.iii). Note that for simplicity the “START DATE” fields only show the date. Thus, for the first entry in the agent task data entity 34, the value “011504” represents the date Jan. 15, 2004.
        (5.v) A date and time stamp (denoted “END DATE”) for retaining the date and time (if available) that the agent was removed from the group identified in (5.iii). Note that for simplicity the “END DATE” fields only show the date. Thus, for the third entry in the agent task data entity 34, the value “022805” represents the date Feb. 28, 2005.
    
    


FIG. 5 is a flowchart showing the high level steps performed when creating a simulated agent group (also, equivalently denoted a “trial group” herein) according to the present first embodiment of the method and data architecture disclosed herein. In particular, in step 48, a trial or simulated group data entity 28 (GDE) is created in the database, wherein the trial group field (i.e., “TRIAL GROUP”) is set to identify the group data entity GDE as a simulated group. Additionally, the “START_DATE” field of GDE is set to a date and time sufficiently in the past so that all desired performance data for agents to be added to the simulated group will be accessible via the group data entity for the simulated group. Note that in FIG. 2, the group data entity 28-4 represents the group data entity for the simulated group 3, and the group data entity 28-5 represents the group data entity for the simulated group 4. Also, a surrogate group key is provided to identify additional versions of various data fields for each of the trial groups.
Subsequently, in step 50, the following substeps are performed for each agent to be added to the simulated group G:

    
    
        (A) Find (or access) the agent data entity 20 (ADE) for the agent, wherein this agent data entity includes the natural key (AK) for the agent to be added.
        (B) For each agent data entity 20 ADE, add a new entry (E) to the membership entity 40, wherein the entry E associates the natural key value AK with the simulated group natural key GNK. Additionally, the start date for the new membership entry is set to a date and time sufficiently in the past so that all desired performance data for the agent will be accessible via this entry. Note that entries identified as M6 and M7 of membership entity 40 (FIG. 3B) illustrate the entries that are added in this substep for simulated agent group 3 (wherein the “START DATE” identifies Jan. 1, 2000), and entries identified as M8 and M9 of membership entity 40 illustrate the entries that are added in this substep for simulated agent group 4.
    
    


Note that after a simulated group is created (regardless of whether the data organization and method is according to the first embodiment hereinabove, or the second embodiment described hereinbelow), various simulations can be performed on historical agent data for agents in the simulated group. For example, the following simulations may be performed:

    
    
        (6.i) Determine an average number of customer contacts processed per day by the agents of the simulated group, wherein the average is determined from historical agent data for each agent from only the previous year; such an average may be used as a measure of an expected performance of the simulated group.
        (6.ii) Determine for each agent of the simulated group, the agent's maximum number of customer contacts processed in a three month period; wherein when such a maximum is determined for each agent, the sum of these maximums over all agents of the simulated group is likely to be an upper bound on the group's performance.
        (6.iii) Determine for each agent of the simulated group, the agent's minimum number of customer contacts processed in a three month period (such that the agent was in a full-time customer contact position); wherein when such a minimum is determined for each agent, the sum of these minimums over all agents of the simulated group is likely to be a lower bound on the group's performance.
        (6.iv) Determine any of the above simulations for a particular type of customer contact, such as customer contacts for merchandise returns, or customer contacts for accounting inquiries.
    
    


Note that to perform such simulations, the simulated group is identified, e.g., by the group's natural key, then using this key, the membership entity 40 is accessed for determining the natural key for each agent of the simulated group. Then using the agent natural keys, the corresponding agent data entities 20 are accessed for obtaining the agent's surrogate keys, and these surrogate keys are then used to access archived agent task data via the agent task data entity 34. In particular, the task data (also referred to as “agent performance data” herein) in the “TASK DATA” field of the entries in the entity 34 may be accessed for each agent of the simulated group once it is determined that the corresponding “TIME STAMP” field for such entries is within the time range that is desired for retrieving such task data in order to simulate the performance of the simulated group. Such a time range may be from a predetermined time previous to the creation of the simulated group and extend to substantially to a present time. However, it is within the scope of the present disclosure to also calculate a performance measurement of a simulated group according to one or more time ranges, wherein such time ranges may have predetermined upper time limits as well. Thus, the likely performance for a simulated group may be determined using a particular year as the time range, or, e.g., a time range specific to each agent such as the latest year that the agent performed a particular type of contact center task.
Further note that similar performance measurements may also be obtained for actual groups. However, since an actual group is preferably restricted to Type 2 behavior, agent task data prior to an agent joining the actual group is typically not available for determining a group performance measurement.
Subsequently, referring to FIG. 1 again, after time T2 the simulated group 3 is converted to an actual group. FIG. 6 shows the high level steps performed when a simulated group is converted to an actual group according to the first embodiment of the method and data architecture disclosed herein. Accordingly, in step 74, the natural key for the simulated group (G) is obtained, and this natural key is used to access the corresponding group data entity 28 for the group. Once the group data entity 28 is accessed: (1) change the simulated group field so that it identifies the group G as an actual agent group (i.e., set the “TRIAL GROUP” field to “N”), and (2) change the group data field “START_DATE” to the date and time that the simulated group is converted to an actual (i.e., non-simulated) group (rather than a date in the past used for accessing agent's records during simulations). Subsequently, in step 76, a determination is made as to whether the data related to simulations performed on the simulated group G is to be retained after the group is converted to an actual group. For example, such simulations may yield an expected performance of the group G such as a total number of customer contacts per month that is expected to be processed by group members. Note that such simulation data may be subsequently used to:

    
    
        (7.i) calibrate or verify the accuracy of a simulation technique for predicting a performance of simulated groups that are converted to actual groups;
        (7.ii) determine performance goals for the converted group;
        (7.iii) determine a plurality of new agent groups, wherein simulations of each of the new groups, indicate that the groups should all perform similarly. Note that such balancing of agent groups may be desirable to motivate groups to compete with one another; and/or
        (7.iv) determine how well a supervisor performs in managing a converted agent group in comparison to a predicted group performance derived from simulations of the group.
    
    


If it is determined in step 76 (FIG. 6) that historical agent performance data is to be disassociated from the converted group, and any group simulation data is to be deleted, then step 77 is performed. Accordingly in step 77, entries in the membership entity 40 for the group have their “START_DATE” changed to the date and time that the simulated group is being converted to an actual group. Additionally, any derived group simulation information accessible via the group natural key is also deleted. It is, however, within the scope of the present disclosure to retain such derived group simulation information even though the historical agent performance data (from which such simulation information is obtained) is no longer accessible from the group data entity.
Alternatively, if it is determined in step 76 that agent and/or group performance data for the simulated group is to be retained, then the flowchart of FIG. 6 ends.
FIG. 3C shows the membership entity 40 at time T3, and the modified group 3 data entity at time T3, wherein modified fields are in bold.
In FIG. 7 a flowchart is shown illustrating the steps performed when a simulated group (G) is modified. In step 80, the natural key (i.e., the value for the GROUP_NATURAL_KEY field) of the group data entity 28 (GDE) of the simulated group is obtained. In step 84, a determination is made as to whether the modification to the simulated group is for changing one or more agents of the group, or changing some other group information (e.g., proposed group supervisor). If there is to be a change in the agents for the simulated group, then step 88 is performed wherein a determination is made as to whether an agent is to be added to the simulated group, or deleted from the simulated group. If an agent is to be added to the simulated group, then step 92 is performed, wherein the step 50 of FIG. 5 is performed. Alternatively, if an agent is to be deleted from the simulated group, then step 94 is performed, wherein the following substeps are performed:

    
    
        (A) Obtain the natural key (e.g., from the agent data entity 20) for the agent (AGNT) to be deleted; and
        (B) Remove the membership entry that associates the agent AGNT with the simulated group from the membership entity 40.
    
    


Alternatively, if in step 84, it is determined that other data for the simulated group is to be modified, then step 96 is performed, wherein such other data (e.g., group supervisor, group agent call type assignments, group performance goals, etc.) is changed via accessing the group data entity 28 for the simulated group G.
Subsequently, regardless of the flow of control from step 84, step 98 is performed, wherein a determination is made as to whether there is at least one additional modification to be performed on the simulated group G. If not, then the flowchart ends. Alternatively, step 84 is again performed.
FIG. 8 shows a flowchart for the deletion of a simulated group as, for example, is performed between times T3 and T4 of FIG. 1. Accordingly, in step 100, the natural key for the trial group (G) is obtained, and in step 104, this natural key is used to access the group data entity 28 (GDE) for the group G, wherein the current date and time are then entered in the “END DATE” field of GDE. Subsequently, in step 108, for each agent of the group G, the corresponding membership entry (in the membership entity 40) that associates the agent with the group G is accessed and the current date is provided in the “END DATE” field of this entry.
FIG. 3D shows the membership entity 40 at time T4, wherein modified fields are in bold.
A second embodiment of the method and data architecture disclosed herein is illustrated in FIGS. 4A through 4D, and FIGS. 9 through 12. That is (as with the first embodiment), the method and data architecture maintains Type 2 time-based database constraints on data entities, e.g., agent data entities 20, and agent group data entities 28 (for actual agent groups), whereas for a simulated group, access to agent data for agent performed tasks occurring substantially prior to the simulated group is accessible via one or more keys for the simulated agent group. In this second embodiment, agent surrogate keys are used in representing agent membership in groups. Thus, in FIG. 4A, a second embodiment 150 of the membership data entity is shown. In particular, the membership entity 150 of FIG. 4A is also representative of, e.g., the time T1 (FIG. 1). Similar to the membership entity 40 described above, the membership entity 150 includes a plurality of membership associations (each such association represented here as a row in the membership entity 150), wherein each row includes the following fields:

    
    
        (8.i) A membership key (denoted “MEMBERSHIP KEY”) uniquely identifying the row.
        (8.ii) An agent key that uniquely identifies an agent. Note that, instead of identifying an agent by his/her natural key (as in membership entity 40), in the membership entity 150 agent surrogate keys are used.
        (8.iii) A group key that uniquely identifies a group in which the agent is a member. Note that group natural keys are used for identifying the group in which the agent identified in (5.ii) is a member. However, in one embodiment, the group's surrogate key may be used. Note that it is believed that group natural keys are generally sufficient to be used in the membership entity 150 since most modifications to a group (other than a change in one or more agents) are likely to be implemented in the data architecture disclosed herein by termination of the group, and subsequent creation of a corresponding new group. For example, if a new supervisor were assigned to an existing group, then it may be preferred to terminate the existing group, and commence a new group having the same agents as the previously existing group but with a new supervisor identified by the group's data entity 28.
    
    


Note that the first five entries of membership entity 150 of FIG. 4A correspond to the first five entries of membership entity 40 of FIG. 3A (with the exception that the entries in entity 150 do not include start and end dates). That is, for each membership entity 40 and 150:

    
    
        M1 corresponds to agent A becoming a member of group 2 (on Jan. 15, 2004);
        M2 corresponds to agent B becoming a member of group 1 (on Mar. 1, 2004);
        M3 corresponds to agent C becoming a member of group 2 (on Dec. 2, 2004);
        M4 corresponds to agent D becoming a member of group 1 (on Jan. 1, 2005); and M5 corresponds to agent D becoming a member of group 2 (on Feb. 2, 2005). Note, however, that the entry M5 of entity 150 includes a different surrogate key from entry M4. That is, in this second embodiment of the method and data architecture, when agent D is added to group 2, a new agent data entity 20-5 is created having a new surrogate key “DSK2”, and this key is then used to identify that the agent D is a member of group 2 in the membership entity 150 (FIG. 4A), as described further hereinbelow. Moreover, since the previous version of the agent data entity (20-4) for agent D has been supplanted with a newer version, the “END DATE” field of 20-4 is filled-in as also shown in FIG. 4A.
    
    


Additionally, note that membership entity 150 of FIG. 4A also includes additional entries in comparison to membership entity 40 of FIG. 3A; i.e., M6 and M7. The entry M6 is due to what is known in the art as “backsplash”, wherein in order to continue to reflect that agent D is in group 1 (after agent D is added to group 2), agent D's new surrogate key “DSK2” must be associated with the group key for group 1, i.e., GK(1). The entry M7 is due to agent D being deleted from group 2 on May 2, 2005; i.e., since agent data entities are Type 2 data modeling entities, a change to the agent D is reflected by creating an additional agent data entity 20-6 (FIG. 4A) that has a new surrogate key “DSK3” for agent D. Accordingly, to continue to reflect that agent D remains a member of group 1 (after being deleted from group 2), entry M7 is required in the membership entity 150 of FIG. 4A.
It is also important to note that since agent C was deleted from group 2 on Feb. 28, 2005, the agent data entity 20-3 is updated with an end date (FIG. 4A), and a new agent C data entity 20-7 is created having a new surrogate key “CSK2”.
FIG. 9 is a flowchart showing the high level steps performed when creating a simulated agent group (also, equivalently denoted a “trial group” herein) according to the second embodiment of the present method and data architecture. In particular, in step 204, a trial or simulated group data entity 28 (GDE) is created in the database having the data schema and data of FIGS. 2 and 4A, wherein the trial group field is set to identify the group data entity GDE as a simulated group. Additionally, the “START_DATE” field of GDE is set to a current date and time. Also, a surrogate group key is provided to identify additional versions of various data fields for the group (identified as “GSK”). Subsequently, in step 208, for each agent to be added to the simulated group G, identify the current (i.e., most recent) agent data entity 20 (AGNT_ENTITY) that identifies the agent (for some portion of time, i.e., each version of the agent data entity for the agent). For each instance of AGNT_ENTITY, determine the surrogate key (AGENT_SURROGATE_KEY) value identifying the instance and add an entry to the membership entity 150 for associating the surrogate key value with a surrogate key value that identifies the most recent version of the simulated group G (see FIG. 4B, membership entity 150, entries M8 through M14).
Subsequently, in step 212, the following substeps are performed for each agent to be added to the simulated group G:

    
    
        (a) Find the current (or most recently created) agent data entity 20 for the agent, and enter a value for the “END_DATE” field identifying the date that the agent is added to the simulated group G. Note that agent data entities 20-1, 20-2, 20-6, and 20-7 are modified in this substep so that their “END_DATE” fields are filled-in as illustrated in FIG. 4B.
        (b) Create a new agent data entity 20 (identified as ADE here) for the agent, wherein ADE includes (1) a value (NSK) for the AGENT_SURROGATE_KEY field that will uniquely identify ADE, and (2) a value for the “START_DATE” field indicative of when ADE is to become the new current version of information identifying the agent (such a value will most likely be the current time and date value for the creation of the simulated group G). Note that the new agent data entries 20-8, 20-9, 20-10, and 20-11 (FIG. 4B) illustrate the entries that are created in various activations of this substep.
        (c) For each new agent data entity 20 ADE, add a new entry (E) to the membership entity 150, wherein the entry E associates the new agent surrogate key value NSK with and the simulated group natural key (GNK) for the group G. Note that the entries identified as M8 and M9 of membership entity 150 (FIG. 4B) illustrate the entries that are added in this substep for simulated agent group 3, and entries identified as M12 and M13 of membership entity 150 illustrate the entries that are added in this substep for simulated agent group 4.
        (d) Since the membership entity 150 must accurately reflect group membership by associating the most recent version of the agent's AGENT_DATA_ENTITY 20 with each group in which the agent is currently a member, additional new entries must be added to membership entity 150. In particular, for each group (Gi) in which the agent is currently a member, create a new corresponding entry (NEi) in the membership entity 150, wherein NEi has the new surrogate key NSK associated with natural key for the group Gi. The entries M10, M11 and M14 of FIG. 4B illustrate the entries that are added in various activations this substep. Note, the process of this substep (d) is known in the art as “handling backsplash”.
    
    


For example, after step 212 is performed for the two simulated groups 3 and 4 at time T3 (FIG. 1), the resulting data entities includes: the data entities of FIG. 2, together with their modifications and new the AGENT_DATA_ENTITIES 20 of FIGS. 4A and 4B, and the version of the membership entity 150 of FIG. 4B.
FIG. 10 shows the high level steps performed when a simulated group G is converted to an actual group according to the second embodiment of the method and data architecture disclosed herein. Note that steps 274 and 276 are identical to steps 74 and 76 of FIG. 6. However, if it is determined (in step 276) that data for the simulated group is not to be retained, then in step 277, for each agent (A) in the group G, the following substeps are performed:

    
    
        (a) Remove all the entries in the membership entity 150 identifying the agent A as a member of the group G;
        (b) Create a new agent data entity 20 for the agent A with (1) a new surrogate key (NSK) for the agent, and (2) the “START_DATE” set to the current time and date;
        (c) Add a membership record (e.g., row) to the membership entity 150 designating that the agent A is a member of the group G; and
        (d) Activate an operation for “handling backsplash” from substep (c) above into the membership entity 150; i.e., for each group (CG) in which the agent is currently a member, create a new corresponding entry (NE) in the membership entity 150, wherein NE associates: the new surrogate key NSK, and the natural key for the group CG.

In particular, for each agent (AGNT) of the group G, each membership entry associated with an agent data entity 20 (for AGNT) having a “START_DATE” prior to the current “START_DATE” field of the group entity data 28 for the group G is removed. For example, in FIG. 4C shows the membership entity 150 after simulated group 3 is converted to an actual group, wherein entries M10 and M11 of FIG. 4B are removed. Alternatively, if all prior data for the simulated group is to be retained after conversion, then no modifications to the membership entity 150 are needed.

    
    


In FIG. 11, a flowchart is shown illustrating the steps performed when a simulated group is modified according to the second embodiment of the method and data architecture. In step 404, the natural key (i.e., the value for the GROUP_NATURAL_KEY field) of the group data entity 28 (GDE) for the simulated group is obtained. In step 408, a determination is made as to whether the modification to the simulated group is for changing one or more agents of the group, or changing some other group information (e.g., proposed group name). If there is to be a change in the agents for the simulated group, then step 412 is performed wherein a determination is made as to whether an agent is to be added to the simulated group, or deleted from the simulated group. If an agent is added to the simulated group, then step 416 is performed, wherein the step 212 of FIG. 9 is performed. Alternatively, if an agent is to be deleted from the simulated group, then step 420 is performed, wherein the following substeps are performed:

    
    
        (A) Find the current (or most recently created) agent data entity 20 for the agent to be deleted, and enter a value for the “END_DATE” field identifying the date that the agent is deleted from the simulated group.
        (B) Create a new agent data entity 20 (identified as ADE) for the agent, wherein ADE includes (1) a new value (NSK) for the AGENT_SURROGATE_KEY field that will uniquely identify ADE, and (2) a value for the “START_DATE” field indicative of when the agent was deleted from the simulated group.
        (C) Handle the backsplash in the membership entity 150 so that the membership entity 150 accurately reflects group membership by associating the most recent version of the deleted agent's AGENT_DATA_ENTITY 20 with each group in which the agent is currently a member (other than the simulated group from which the agent is being deleted), additional new entries must be added to membership entity 150. In particular, for each group (CG) in which the agent is currently a member, create a new corresponding entry (NE) in the membership entity 150, wherein NE has the new surrogate key NSK associated with current natural key for the group CG.
    
    


Alternatively, if in step 408, it is determined that other information for the simulated group is to be modified, then step 424 is performed. In the present embodiment, it is assumed that such “other group information” resides in a “group attribute data entity” (e.g., a record) that is distinct from the trial group data entity GDE. Accordingly, the trial group's current surrogate key may be used to access the trial group's current attributes, and once the desired changes are made to such current attributes, a new group attribute data entity is created having the desired changes. Subsequently, a new surrogate key for the group is generated which is used to access the new group attribute data entity, and a new “current” version of the group data entity is generated wherein this new version includes this new surrogate group key.
Subsequently, regardless of the flow of control from step 408, step 428 is performed, wherein a determination is made as to whether there is at least one additional modification to be performed on the simulated group. If not, then the flowchart ends. Alternatively, step 408 is again encountered.
FIG. 12 shows the flowchart for the deletion of a simulated group according to the second embodiment of the method and data architecture. The steps of this flowchart are self explanatory in view of the description hereinabove.
To perform group simulations using the second embodiment of the of the method and data architecture disclosed herein, a simulated group is identified (e.g., by the group's natural key), then using this key, the membership entity 150 is accessed for determining the surrogate key for each agent of the simulated group. Then, using these agent surrogate keys, archived agent task data via the agent task data entity 34 is accessed. In particular, the task data (i.e., “agent performance data”) in the “TASK DATA” field of the entries in the entity 34 may be accessed for each agent of the simulated group once it is determined that the corresponding “TIME STAMP” field for such entries is within the time range that is desired for retrieving such task data in order to simulate the performance of the simulated group. Such a time range may be from a predetermined time previous to the creation of the simulated group and extend to substantially to a present time. However, it is within the scope of the present disclosure to also calculate a performance measurement of a simulated group according to one or more time ranges, wherein such time ranges may have predetermined upper time limits as well. Thus, the likely performance for a simulated group may be determined using a particular year as the time range, or, e.g., a time range specific to each agent such as the latest year that the agent performed a particular type of contact center task.
The above described method and data architecture may be used in performing simulations of groups other than contact center agent groups, as well as other contact center managed resources such as VDNs (e.g., routing points) and/or agent skills (e.g., “queues”, as one skilled in the contact center art will understand). For example, groups of sales representatives may be simulated using a similar data architecture and method, wherein past performance data for each salesperson may be related, e.g., dollar amount of merchandise sold. Moreover, squadrons (i.e., groups) of military personnel may be simulated using the method and data architecture disclosed herein, wherein past performance data for each military person may be related to past proficiency at certain military skills. Further, the method and data architecture disclosed herein may be used for capturing data related to the projected sales of various combinations of telecommunications features, as one skilled in the art will understand. For example, the data architecture and method described herein may be used for simulating the likely commercial success of various packages of telecommunications services, and for retaining the historical data upon which the simulation(s) were performed; e.g., the historical data may include sales of particular services and their users.
Moreover, as one skilled in the art will understand, the data entities disclosed hereinabove can be readily implemented in a relational database architecture such that each of the data entities (and/or instances thereof) hereinabove are embodied in one or more relational database tables. Moreover, since a database providing the database entity schema architecture and operators disclosed herein will reside data storage hardware such as magnetic disk media, and/or optical data storage media for storing the data entities, it is within the scope of embodiments of the present invention to include such hardware components for enabling such embodiments. Additionally, since the operators (e.g., as described in the flowcharts of FIGS. 5 through 12) are performed on one or more computational devices such as a computer or a network of computers, it is within the scope of embodiments of the present invention to include such computational components for enabling these embodiments. Also, the present invention includes storage media for transporting and/or retaining an encoding of programmatic elements (e.g., software in source code, object code or binary form) for enabling the database entity schema architecture and operators disclosed herein, such storage media being, e.g., magnetic or optical media, as one skilled in the art will understand.
The foregoing description has been presented for purposes of illustration and description. However, the description is not intended to limit the invention as claimed hereinbelow to the form disclosed hereinabove. Consequently, variations and modifications commensurate with the above teachings, within the skill and knowledge of the relevant art, are within the scope of the claims hereinbelow. The embodiments described hereinabove are further intended to explain the best mode presently known of practicing the invention claimed hereinbelow, and to enable others skilled in the art to utilize the claimed invention in various embodiments, and with the various modifications required by their particular application or uses of the invention. Thus, it is intended that the appended claims be construed to include alternative embodiments to the extent permitted by the prior art.

## Claims

1. A method for simulating a group, comprising:
providing a data storage medium having a predetermined group database entity type wherein each instance of the group database entity type includes:
(a-1) an identification storage area for identifying a corresponding group of items, and
(a-2) a group type storage area for identifying the corresponding group as one of:
(i) an actual group of one or more items, and
(ii) a simulated group of one or more items;

wherein the predetermined group database entity type defines a substantially entire data organization for each instance of the group database entity type within a data repository;
providing access to at least a first instance of the predetermined group database entity type using a value in the identification storage area of the first instance, wherein a value for the group type storage area identifies the first instance as corresponding to an actual group (G1) of one or more items;
wherein for evaluating a performance of the first instance, item performance data (ED1) associated with the items of the actual group G1 is accessed according to Type 2 constraints for accessing ED1, wherein the item performance data ED1 is substantially for a time period no earlier than a creation of the actual group G1;
creating a second instance of the predetermined group database entity type on the data storage medium, wherein the second instance corresponds to a simulated group (G2) of one or more items;
wherein the step of creating includes storing a predetermined time value for determining, for the items of G2, an earliest date of creation for item performance data that is desired for simulating an evaluation of G2, wherein the predetermined time value is substantially prior to the creation of G2;
second evaluating a performance of the simulated group G2, wherein item performance data (ED2) associated with the items of the simulated group G2 is accessed for performing the second evaluation;
wherein the accessing of the item performance data ED2 is determined using the predetermined time value;
wherein the predetermined group database entity type provides a common data structure for accessing substantially all data for each of the first and second instances and wherein a supervisor of the actual group G1 is enabled to create the simulated group G2 and wherein the simulated group G2 created by the supervisor comprises an agent not in the actual group G1.

2. The method of claim 1, wherein the item performance data ED1 includes data for identifying a task performed by a first item from the first instance, and the item performance data ED2 includes data for identifying a task performed by a second item from the second instance, and the first and second items are each an agent of a contact center.

3. The method of claim 1, wherein the item performance data ED1, includes first data for identifying a task performed by a first item from the first instance, and the item performance data ED2 includes second data for identifying a task performed by a second item from the second instance, and the first and second data entries are substantially in an identical in data format.

4. The method of claim 1, wherein the predetermined group database entity type defines a data format within a relational database.

5. The method of claim 1, wherein the step of creating includes updating a membership database entity type for identifying the items in group G2 wherein at least one additional entry is added to the membership database entity type, the at least one additional entry including the predetermined time value.

6. The method of claim 5, further including a step of converting the second instance so that G2 is identified as an actual group, wherein the step of converting includes removing an entry from the membership database entity type, wherein the removed entry associates data for an item of G2 with the second instance.

7. The method of claim 5, wherein the instances of the group database entity type and the membership database entity type are provided as tables in a relational database.

8. The method of claim 5, wherein at least one entry in the membership database entity type includes a surrogate key for identifying data for an item of G2, wherein the data is part of the item performance data ED2.

9. The method of claim 1, wherein the step of creating includes updating, via a backsplash process, a membership entity having information identifying the items in groups corresponding to instances of the group database entity type, wherein at least one additional entry is added to the membership entity, the at least one additional entry for providing access to a new data entity corresponding an item of the group G2, wherein the additional entry is for a group different from G2.

10. An apparatus for evaluating groups, comprising:
one or more data repositories for storing instances of a predetermined group database entity type such that each instance of the group database entity type includes:
(a-1) an identification storage area for identifying a corresponding group of items, and
(a-2) a group type storage area for identifying the corresponding group as one of:
(i) an actual group of one or more items, and
(ii) a simulated group of one or more items;

at least a first of the instances of the predetermined group database entity type, the first instance identified as an actual group (G1) of one or more items;
at least a second of the instances of the predetermined group database entity type, wherein the second instance corresponds to a simulated group (G2) of one or more items;
one or more evaluators for evaluating a performance of the groups G1 and G2 using, respectively, the first and second instances;
a processor, wherein the processor is operable to perform operations on group database entities;
one or more instances of an agent data entity type, wherein the one or more instances of the agent data entity type provide access to a timestamp field for receiving a time value that identifies a latest creation time for data indicative of a performance of the agent that is associated with the one or more instances of the agent data entity type, and wherein the one or more instances of an agent data entity type comprise the items of group G1 and group G2;
wherein for evaluating the group G1, item performance data (ED1) associated with the items of the actual group G1 is accessed according to Type 2 constraints for accessing ED1, wherein the item performance data ED1 is substantially for a time period no earlier than a creation of the actual group G1;
wherein for evaluating the group G2, a predetermined time value is accessed, wherein the predetermined time value is for determining, for the items of G2, an earliest date of creation for item performance data (ED2) associated with the items of the simulated group G2, wherein the predetermined time value is substantially prior to the creation of G2 and wherein a supervisor of the actual group G1 is enabled to create the simulated group G2 and wherein the simulated group G2 created by the supervisor comprises an agent not in the actual group G1.

11. The apparatus of claim 10, wherein the one or more data repositories include storage for a programmatic element for converting the second instance into an instance corresponding to an actual group.

12. The apparatus of claim 10, wherein the one or more instances of the agent data entity type also provides access to at least one key (K) for identifying the agent.

13. The apparatus of claim 12, wherein the corresponding instance of the predetermined agent data entity type provides access to a timestamp field for receiving a time value identifying an earliest time for data indicative of the performance of the agent that can be accessed via the corresponding instance.

14. The apparatus of claim 12, wherein the K is a surrogate key.