Combination Checks
Combination checks compare the claim line that is adjudicated to other claim lines, both in the same and in other claims.
A combination check has a number of settings that specify under what circumstances the check applies. When the check triggers, it searches all claim lines for the same member with a specified time window.
A combination check does not trigger for locked lines and replaced lines, and it ignores replaced lines when searching for other lines. Note that combination checks apply to sub-claims in the same way as a regular claim. However, they are not relevant for large claims.
After a combination check finds a list of non-replaced claim lines for the same member within the specified time window, the function specified on the combination check applies the user specified filter criteria. If any of the claim lines meets these filter criteria, the check succeeds and attaches a message to the triggering claim line.
There are three scenarios that a combination check supports:
-
Checking for duplicate claim lines
-
Checking for mutually exclusive services
-
Checking for services that are required to be claimed together
Consider the following examples:
A provider sends in two separate claims for the same heavy surgery, on the same day, by the same surgeon. Because it is impossible for a patient to undergo the specified surgery twice in one day, the payer wants the system to automatically deny one of the claims.
A provider sends in two separate claims for a doctor consult, on the same day, by the same doctor. Because it is unlikely for a person to go to the same doctor twice on the same day, the payer wants the system to pend the claim for manual adjudication.
A provider sends in two dental claims, one for a crown, one for bridge and both for the same tooth. Because it is impossible to have both a crown and a bridge for the same tooth, the payer wants the system to automatically deny the triggering claim line.
A provider sends in a claim for dental anesthesia. The payer wants the system to check for another claim line with the same service date and a procedure that actually warrants dental anesthesia. This could be a number of different dental procedures, ranging from the pulling of a single tooth to extensive dental surgery. If the system does not find a claim line with the same service date and with a dental procedure that warrants anesthesia, the system should automatically deny the triggering claim line.
Combination checks are applied at a specific point in the process flow, before the system has fully adjudicated the triggering claim line. For example, a combination check that says line A should always go together with line B will simply check if line B is present when it encounters line A. If, at a later point in the process, line B is denied, it does not automatically also deny line A as a result of that combination check.
Entity Model
A combination check contains the following attributes:
- Combination Check
-
.Combination Check
Field | Description |
---|---|
Code |
The unique code of the combination check |
Description |
The description of the combination check |
Step |
Specifies the step in the flow where this combination check is executed: at the start of pricing ('S') or pre benefits ('B'). |
Sub-Type |
Specifies whether this is a duplicate, exclusive or mandatory combination check. The sub-type drives the way that the check is processed and whether a successful search should lead to a claim line message. |
Procedure Group |
Specifies a procedure group. |
Procedure Group 2 |
Specifies a 2nd procedure group. |
Procedure Group 3 |
Specifies a 3rd procedure group. |
Condition Dynamic Logic |
The condition when to apply the combination check |
Period before |
The number of units that the service date of the claim line may differ from the triggering claim line (before) |
Period after |
The number of units that the service date of the claim line may differ from the triggering claim line (after) |
Period (unit of measure) |
The unit for the period before and period after (Day, Month or Year) |
Dynamic Logic Function |
Specifies the search criteria that must be met when searching across claim lines. |
Message |
The message that is attached to the triggering claim line. |
Enabled indicator |
This combination check is only executed when this box is checked |
Start date |
The start date of the combination check |
End date |
The end date of the combination check |
- Combination Check Procedure
-
.Combination Check Procedure
Field | Description |
---|---|
Combination check |
The combination check for which specific procedures are defined. |
Procedure |
The procedure |
Procedure 2 |
The second procedure |
Procedure 3 |
The third procedure |
Start date |
The start date of the usage of the combination check procedure. |
End date |
The end date of the combination check procedure. |
A combination check procedure a between 1 and 3 procedures.
- Combination Check Claim Form
-
.Combination Check Claim Form
Field | Description |
---|---|
Combination check |
The combination check for which specific claim forms are defined. |
Claim form |
The form of the incoming claim. |
There are three types of combination check:
Duplicate Check - Choose this type to search for an identical line and configure the matching criteria the function. If an identical claim line is found, then the check attaches a message to the triggering claim line.
Exclusive Combination Check - Choose this type to detect mutually exclusive claim line services. If a conflicting claim line is found, then the check attaches a message to the triggering claim line
Mandatory Combination Check- Choose this type when to impose a mandatory combination of claim lines. If the required claim line is not found, then the check attaches a message to the triggering claim line
Duplicate checks are executed prior to exclusive and mandatory combination checks.
The combination check can specify up to three procedure groups and an unlimited number of procedures. A claim line triggers the check, when the procedure(s) on the line match the procedure(s) on the combination check.
-
Procedure Groups: a combination check can specify up to 3 procedure groups. A claim line triggers the check if for each procedure group specified on the combination check, the claim line has at least one procedure that is included in that procedure group on the claim line start date.
-
Procedures: a combination check can specify a list of procedure combinations. Each procedure combination specifies between 1 and 3 procedures. A claim line triggers the check if at least one procedure combination in the list fully matches. Procedure combinations that are not effective on the claim line start dare ignored.
If both procedure groups and procedure combinations are specified, then the combination check only applies to claim lines that match on both the procedure groups AND at least one of the procedure combinations.
In addition to procedure related triggers, the combination check can be scoped on claim form and on a user defined dynamic logic condition.
When a claim line triggers a combination check, the system retrieves all other claim lines for the same member within the specified time window. The dynamic logic function specifies the filter criteria.
Consider the following example function. It filters for any claim line that has a procedure with a code that matches on the first 3 characters with the triggering claim line.
// script for duplicate match based on the first three digits of the procedure code // the claimLineList is already filtered on member and time window prefix = triggeringClaimLine.procedure.code.substring(0,3) for (claimLine in claimLineList){ // the same first three digits in the procedure code if ( claimLine.procedure.code.startsWith(prefix) ) { return claimLine } } return null
In the function, the claimLines object is a list of all claim lines that:
-
are for the same member, excluding the triggering line itself
-
have a start date within the time window specified on the combination check;
-
have not been replaced;
If the property ohi.claims.ignore.history is set to TRUE, then the claimLinesList object is confined to claim lines in the same claim as the triggering claim line.
The claimLines object is the same for both start pricing and pre benefits combination checks.
The dynamic logic function can specify additional filter criteria, for example:
-
Exclude claim lines in a certain status
-
Exclude claim lines that are denied
-
Exclude claim lines that have a different diagnosis code
The message that is attached to the triggering claim line can use the following values by including the listed number in brackets:
-
[0] for the claim code
-
[1] for the claim line code
-
[2] for the userDefinedParameters [2] to assign in a function
-
[3] for the userDefinedParameters [3] to assign in a condition
For example, a message text that uses these parameters is configured as "Claim {0}, claim line {1} is a suspect duplicate claim line".
The severity of the message determines what happens after the combination check. A fatal message results in the triggering line being denied. An informative message can be used to pend the claim for human review.
Examples
Duplicate Services
The following two checks both detect duplicate claim lines for dental procedures. The first check detects exact duplicate lines. Exact matches are always denied. The second check detects suspected duplicate lines. Suspected duplicate lines get an informative message, so that they can be pended and adjudicated by a human operator.
Both checks trigger for claim lines with a procedure in the group DENTAL.
-
Check 1 attaches a fatal message if there is an exact match on the procedure code, service date and service provider.
-
Check 2 attaches an informative message if the first three digits of the procedure code match and the service dates are no more than 3 days apart.
For the first check, set up a function called EXACT_DUPE_FUNC:
// script for exact duplicate match for (claimLine in claimLineList){ // claim line has the same servicing provider if ((triggeringClaimLine.serviceProvider==claimLine.serviceProvider) // claim line has the same procedure code && (triggeringClaimLine.procedure.code==claimLine.procedure.code) // claim is adjudicated or finalized && (["FINALIZED","ADJUDICATION DONE"].contains(claimLine.claim.status)) // claim line may not have a fatal message && !claimLine.hasFatalMessage() ) { return claimLine } } return null
For the second check, set up a function called SUSPECT_DUPE_FUNC:
// script for suspect duplicate match for (claimLine in claimLineList){ if ((substring(0,3, triggeringClaimLine.procedure.code)==substring(0,3, claimLine.procedure.code)) && (claimLine.claim.status in ["FINALIZED", "ADJUDICATION DONE"]) && !claimLine.hasFatalMessage() ) { return claimLine } } return null
Next, set up two messages. The first looks like this:
Code |
EXACT_CUPE_MESS |
---|---|
Severity |
Fatal |
Text |
Claim {0}, line {1} is an exact duplicate claim line. |
The second looks like this:
Code |
SUSPECT_DUPE_MESS |
---|---|
Severity |
Informative |
Text |
Claim {0}, line {1} is a suspect duplicate claim line. |
Finally, set up two combination checks. The first check looks like this:
Type |
Duplicate check |
---|---|
Procedure Group |
DENTAL |
Function |
EXACT_DUPE_FUNC |
Message |
EXACT_DUPE_MESS |
Period before and after |
0 days |
The second check looks like this:
Type |
Duplicate check |
---|---|
Procedure Group |
DENTAL |
Function |
SUSPECT_DUPE_FUNC |
Message |
SUSPECT_DUPE_MESS |
Period before and after |
3 days |
Required Combination of Services
The following example is a check that ensures that the dental procedure D123456 is rejected unless there is a second claim line for an anesthetic, on the same day.
The function ANES_REQ_FUNC looks like this:
// this function returns the first line in the prefiltered list // for an anesthetic service that is not denied for (claimLine in claimLineList){ if ((claimLine.procedure.inProcedureGroup('DENTAL ANESTHESIA')) && !claimLine.hasFatalMessages()) { return claimLine; } } return null;
Next, set up the following message:
Code |
ANESTHETICS REQUIRED |
---|---|
Severity |
Fatal |
Text |
"Claim {0}, line {1} is cannot be claimed without a related claim line for anesthetics." |
Finally, set up the combination check:
Type |
Mandatory combination check |
---|---|
Function |
ANES_REQ_FUNC |
Message |
ANESTHETICS REQUIRED |
Period before and after |
0 days |
With combination check procedure:
Procedure code |
D123456 |
---|---|
Start date |
2020-01-01 |
Mutually Exclusive Services
The following check denies any claim line for a pain suppressing medication in procedure group PAINMEDS, in the event that the same member already claimed another pain suppressing medication from the same group PAINMEDS, within a 24 day period of the service date.
First, set up a function called FIND_DIFFERENT_MEDS, with the following logic:
// this function returns the first line that it finds // that also specifies pain medication from group PAINMEDS // and that is not denied // and that is not the same pain medication as the triggering line for (claimLine in claimLineList){ if ((claimLine.procedure.inProcedureGroup('PAINMEDS')) && !claimLine.hasFatalMessages() && claimLine.procedure != triggeringClaimLine.procedure ) { return claimLine; } } return null;
Next, set up the following message:
Code |
CONFLICTING_MEDS |
---|---|
Severity |
Fatal |
Text |
This line specifies medication that may in conflict with the medication specified by claim {0}, line {1}." |
Finally, set up the following combination check:
Type |
Exclusive combination check |
---|---|
Procedure Group |
PAINMEDS |
Function |
FIND_DIFFERENT_MEDS |
Message |
CONFLICTING_MEDS |
Period before and after |
4 weeks |