Expanding the Boundaries of Health Informatics Using Artificial Intelligence: Papers from the AAAI 2013 Workshop
Procedural Approach to Mitigating Concurrently
Applied Clinical Practice Guidelines
Martin Michalowski
Szymon Wilk
Adventium Labs, USA
Poznan University of Technology, Poland
martin.michalowski@adventiumlabs.com
szymon.wilk@cs.put.poznan.pl
Di Lin
McGill University, Canada
di.lin2@mail.mcgill.ca
Wojtek Michalowski, Xing Tan, Subhra Mohapatra
University of Ottawa, Canada
wojtek@telfer.uottawa.ca, tan@telfer.uottawa.ca, smoha093@uottawa.ca
methods is one of the obstacles in the adoption of CPGs in
clinical practice and the development of these methods has
been identified as one of the “grand challenges” for clinical
decision support (Sittig et al. 2008).
We responded to the above challenge by proposing an automatic mitigation algorithm that verifies if pairs of CPGs
can be applied simultaneously to a patient with comorbid
diseases (Wilk et al. 2013). We described the novel use of
a constraint logic programming (CLP) model to represent
evidence-based guidelines and domain knowledge that goes
beyond what is presented in a CPG, and presented an algorithm that manipulates and solves this model to propose a
combined therapy. The mitigation algorithm was originally
developed under a number of assumptions, two of them being no iterative actions that may produce a cycle and the
use of only binary action variables (i.e., variables associated
with actions prescribed by a CPG). In this paper we are relaxing these assumptions and presenting an extended version
of our mitigation algorithm that resolves a cycle in a CPG
and introduces numerical variables into the logical models.
A cycle in a CPG occurs when one or more actions (usually related to therapy) are repeated several times. Often
the number of iterations or the stop condition is not clearly
stated. While this situation is easily handled by a physician
who knows how and when to stop a cycle, it creates a serious
problem when the CPG is processed automatically. Numerical variables provide a more detailed characteristic of specific actions from a CPG than nominal (especially Boolean)
ones that are used in logical models. In particular, they allow
for the precise representation of medication dosages, allowing for the discovery of interactions resulting in overdosing or those exacerbating the action of one medication by
another. Extending our CLP-based approach to handle cycles and use numerical variables positions the work one step
closer to being used as a decision support tool at the point
of care while providing the research community with new
approaches to modeling medical domain knowledge and determining therapies using a CLP-based approach.
Finally, our long term research goal is to develop a formal
theory for the mitigation of multiple CPGs for a comorbid
patient. The work presented here is a procedural approach
that we show to apply to mitigation under certain assumptions. We are working to further generalize our approach
and Section 5 provides a brief discussion of directions we
Abstract
There is a pressing need in clinical practice to mitigate
(identify and address) adverse interactions that occur
when a comorbid patient is managed according to multiple concurrently applied disease-specific clinical practice guidelines (CPGs). We describe an automatic algorithm for mitigating undesirable interactions for pairs
of CPGs. The algorithm constructs logical models of
processed CPGs and employs constraint logic programming to solve them. It handles two important issues frequently occurring in CPGs – iterative actions forming a
cycle and numerical measurements. Dealing with these
two issues in practice relies on a physician’s knowledge
and the manual analysis of CPGs. Yet for guidelines
to be considered stand-alone and an easy to use clinical decision support tool this process needs to be automated. In this paper we present our algorithm that aims
to build such a tool by mitigating multiple CPGs while
handling cycles and numerical measurements. The application of the mitigation algorithm is illustrated with
a clinical case study involving a comorbid patient suffering from atrial fibrillation in the setting of WolffParkinsons-White syndrome.
1
Introduction
Boyd et al. (2005) discussed the applicability of clinical practice guidelines (CPGs) (see Latoszek-Berendsen et
al. (2010) for the definition of a CPG and a review) to the
care of patients with comorbid diseases. After analyzing
hypothetical clinical scenarios of several common chronic
diseases and associated CPGs, the authors concluded that
adhering blindly to CPG-mandated treatments in the presence of comorbid diseases may negatively impact a patient’s
health. They attributed this situation to the fact that a CPG
is largely developed by a specialty-dominated committee,
and therefore is not designed to provide help with regards
to evaluating and managing comorbid patients. Since developing CPGs that explicitly address all potential comorbid
diseases is difficult and impractical, there is a need for formal methods that would allow combining several diseasespecific CPGs in order to customize them to a specific patient (Fox et al. 2010). Studies show that the lack of such
c 2013, Association for the Advancement of Artificial
Copyright Intelligence (www.aaai.org). All rights reserved.
47
are exploring towards this goal.
2
Available patient
data
Two CPGs given
as actionable graphs
Motivating Clinical Scenario
Consider an elderly male patient complaining of palpitations, shortness of breath and a syncopal episode. At the
time of presentation he was not in any distress but had a
rapid irregular pulse. A 12-lead ECG was done and revealed
an irregular, wide complex tachycardia consistent with atrial
fibrillation (AF) in the setting of Wolff-Parkinsons-White
(WPW) syndrome. The attending physician concluded that
the patient has a chronic condition (WPW) and an acute disease (AF).
Following the guideline for WPW, this patient should be
given flecainide at a low dosage, after which an evaluation
to determine if the patient’s WPW is stable needs to be conducted. If the patient’s WPW condition does not stabilize,
the guideline suggests either increasing the dosage of flecainide, if the level of flecainide is below the maximal safe
dosage for a particular patient, or following another therapy. According to the guideline for AF, the patient will receive electrical cardioversion if hemodynamic instability is
present. Otherwise, the patient is given intravascular injection of flecainide or amiodarone, depending on the presence of structured heart disease. In cases of a recurring AF
episode, the patient is given oral amiodarone.
When treating a patient for both AF and WPW there is
an interplay between the dosages prescribed, specifically the
dosage of flecainide. Overdosing the patient leads to a level
of the drug in the blood that results in toxicity. Therefore
dosages of flecainide need to be expressed in terms of exact,
patient-specific (numerical) values that are changed during
the management process. Additionally, the CPG for WPW
contains a treatment cycle. Thus, handling both repeated actions manifesting as a cycle and the dosage of flecainide is
essential to developing a safe combined therapy for this patient. While AF and WPW serve as the motivating clinical
example for this work, in practice the described interactions
between CPGs are common across many other pairs of diseases.
3
Phase 1: Preparation
Phase 2: Mitigation of direct
adverse interactions
Interaction and
revision operators
Create logical models
from actionable graphs
Identify and address direct
adverse interactions
No interactons
or interactions addressed
Augment combined
logical model
Phase 3: Mitigation of
indirect adverse interactions
Identify and address indirect
adverse interactions
No interactons
or interactions addressed
Success
Report safe therapy
Unable to address
interactions
Failure
Figure 1: Mitigation Algorithm Overview
domain knowledge is codified in the form of interaction and
revision operators. The former characterize possible indirect
adverse interactions between CPGs, while the latter describe
revisions required to address specific adverse interactions.
An overview of the mitigation algorithm is given in Figure 1 and it consists of three main phases: preparation, mitigating direct interactions, and mitigating indirect interactions. It accepts as input two CPGs given as actionable
graphs and available patient information represented as a
set of variable-value pairs. An actionable graph is a directed
acyclic graph with context, action and decision nodes corresponding to context, action and decision steps that appear in
most formal CPG representations (Isern and Moreno 2008).
Actionable graphs can be obtained automatically from other
representations (in Hing et al. (2010) we proposed an algorithm for this purpose) and this property makes our mitigation algorithm representation-agnostic.
The preparation phase starts with the construction of logical models that are logical representations of actionable
graphs. Formally, a logical model of the actionable graph
AGi is defined as LMi =< di , Vi , P LEi >, where di is the
label of a disease associated with AGi , Vi is a set of variables associated with actions and decision nodes in AGi ,
and P LEi is a set of logical expressions representing paths
in AGi , each being a conjunction of variable-value pairs.
These logical models are brought together as a combined
logical model. The combined logical model is formally defined as: CLMi,j =< LMi , LMj , ILEi,j >, where ILEi,j
is a set of logical expressions that represent indirect adverse
interactions between logical models LMi and LMj .
In the mitigation of direct interactions phase the algorithm
checks for direct adverse interactions. It first transforms the
combined logical model into a CLP model (we refer to it as a
CLP-CPG model) and attempts to solve it given patient data
(variable-value pairs instantiated to represent the patient’s
known health state). A solution to the CLP-CPG model is
Mitigation Algorithm
Our mitigation algorithm is described in detail in (Wilk et
al. 2013). In this section we present only its general structure and the relevant concepts affected by our proposed extensions. The mitigation algorithm checks for possible adverse interactions between CPGs, addresses identified interactions and finally finds a combined therapy consisting
of individual therapies derived from both CPGs. We distinguish between two categories of interactions - direct and
indirect. The former manifest as contradicting treatments
given by individual CPGs (e.g., “administer flecaininde”
and “do not administer flecainide”), while the latter manifest as medication-medication or medication-disease interactions (e.g., flecainide should not be given to patients with
kidney disease) and they are not explicitly included in CPGs.
Identifying and addressing adverse interactions requires extensive domain knowledge that comes from clinical experts,
textbooks and repositories of evidence. We assume that this
48
an assignment of values to variables from Vi and Vj such
that no constraints are violated. If a solution exists, it means
there are no direct adverse interactions and the algorithm
passes to the third stage. Otherwise, the lack of a solution
indicates some constraints have been violated thus leading
to infeasibility (similar to conflicting constraints in mathematical programming models). Variables appearing in the
violated constraints form the potential source of infeasibility that drives the step of addressing adverse interactions by
applying revision operators to the combined logical model.
The algorithm checks if all adverse interactions have been
addressed by creating another CLP-CPG model from the revised combined logical model. The lack of a solution at this
point indicates interactions that cannot be addressed and the
algorithm terminates with failure. Otherwise, it proceeds to
the third phase.
The third phase - mitigating indirect adverse interactions is very similar to the second one. The main difference is the
application of interaction operators that codify possible indirect adverse interactions to the CLP-CPG model at the very
beginning of this phase. This augments the CLP-CPG model
with information not present in the original CPGs. Subsequent processing is analogous to the second phase. The algorithm reports failure in the case of adverse interactions
that cannot be addressed or success if there are no interactions or they were successfully addressed. Additionally, the
algorithm returns a possible combined therapy derived from
the solution to the CLP-CPG model.
Handling cycles introduces a new step in the preparation
phase, where a cyclic actionable graph is transformed into an
acyclic one by identifying and expanding cycles. The two
key issues with cycles are: (1) they pose a problem when
transforming an actionable graph into a logical model because a unique variable is needed for each action (and actions in cycles occur multiple times), and (2) often there is
no clear definition of the number of iterations or a stopping
condition. Based on consultations with medical experts we
developed a two-step expand procedure (Figure 2) to remove
a cycle by estimating the number of iterations (extracted directly from a CPG in the easy case or approximated using
expert knowledge in the worst-case scenario) and expanding
the identified cycle.
sumes a single cycle only (handling multiple cycles could be
done by using a recursive invocation of the expand procedure with AGi ). The procedure then uses the identified cycle
and a stopping condition (Stopi ) to determine the maximum
number of iterations (M axIteri ). We establish the stopping
condition according to expert’s opinion, evidence, literature,
or patient information.
Next, we create a forward path (F orwardP athi ) to resolve the cycle. A forward path starts with the first node
identified in the original cycle and includes the remaining
nodes of the cycle. Given the maximum number of iterations, we create a revised actionable graph where the cycle is replaced by a set of connected forward paths, where
the number of these paths is equal to the maximum number
of iterations. The updated actionable graph (AGexp
i ) is then
used to create a logical model. We note that even in simple cases where the number of iterations is known, invoking
the expand procedure is still necessary as it introduces new
variables needed to expand the cycle.
Consider the application of the expand algorithm to the
actionable graph for WPW (AGW P W ) shown in Figure 3.
In order to establish the stopping condition we set DFlow
and ΔDF to 50mg. This is consistent with medical practice
where a patient with WPW (and without structural heart disease) is started on flecainide dosage of 50mg every 12 hours,
increased by 50mg at 4 day intervals. The dosage should not
exceed the safety threshold that keeps the level of flecainide
in plasma between 0.2 and 0.7 mcg/mL.
&!&
!"%
(&
!& "%"
"(
'%&"%"
+
%
%& Require: AGi , Stopi
Cyclei ← identif y cycle(AGi )
M axIteri ← check conditions(Cyclei , Stopi )
F orwardP athi ← create path(Cyclei )
AGexp
← replace cycle(AGi , F orwardP athi , M axIteri )
i
return AGexp
i
"
'$$!&"%
"
%
* %
#"%"
!"&$
&$#) %$
#&!&
Figure 3: Original AGW P W
The relationship between the plasma level and the maximum safe dosage of flecainide is represented by the
DFsaf e (P ) function that accepts an externally provided parameter P indicating the level of flecainide in plasma. After
consulting with a clinician we set P to 0.7 as levels above 0.7
lead to a significant risk of a cardiac episode. This level corresponds to a maximum safe dosage of 200mg that is reached
after 3 iterations, thus the cycle in AGW P W is replaced by
Figure 2: Identifying and removing cycle using the expand
procedure
The procedure begins by identifying the cycle in the actionable graph (AGi ) using a path-based strong component
algorithm (Tarjan 1972). Note that the identification step as-
49
eling therapies where values of numerical variables are established according to some algebraic formula. Below we
show a subset (due to space considerations) of expressions
in P LEW P W derived from AGexp
W P W that contain numerical variables:
'"'
"#&
)'
"'!#&#
&'!
&
1. (DF 0 = 50) ∧ (W S0 = y) ∧ (DF = 50) ∧ DP ∧
¬AT ∧ ¬(DF 1 = 100) ∧ ¬(DF 2 = 150) ∧ ¬(DF 3 =
200) ∧ ¬(DF = 100) ∧ ¬(DF = 150) ∧ ¬(DFsaf e (P ))
$#&#
#
+&
2. (DF 0 = 50) ∧ (W S0 = n) ∧ (DF 0 ≥ DFsaf e (P )) ∧
AT ∧DP ∧¬(DF 1 = 100)∧¬(DF 2 = 150)∧¬(DF 3 =
200) ∧ ¬(DF = 50) ∧ ¬(DF = 100) ∧ ¬(DF = 150) ∧
¬(DFsaf e (P ))
(%%"'#&
#
&
(&'#&#
&'!
&
$#&#
&
$#&#
While the use of numerical variables and algebraic functions in the decision criteria is supported in most current
programming languages, supporting them in our approach
was facilitated by representing logical models as a CLP. A
CLP-based representation made it easier to transition to numerical variables given our access to the wide range of languages and solvers available for CLP. Additionally, using a
standard CLP representation for the CLP-CPG models allows us to take advantage of the scalability offered by CLP
solvers. The CLP-CPG models we have considered thus far
have been relatively small, containing on the order of tens
of variables and constraints and even with an order of magnitude increase in their number we still wouldn’t be pushing
solvers designed to handle tens and hundreds of thousands of
variables as demonstrated by recent benchmark results1 . Using a logic-based representation makes many off-the-shelf
CLP solvers available to us, and we justify our use of the
ECLi P S e system2 in Section 4.
#
+&
(%%"'#&
#
&
(&'#&#
&'!
#
+&
(%%"'#&
#
&
(&'#&#
$#&#
"#'%
'%$* 4
Evaluation
To evaluate the mitigation algorithm, we use different instances of the clinical scenario described in Section 2. As
previously stated codified domain knowledge is represented
using interaction and revision operators. An interaction operator is defined as a 3-tuple <Dk , V k , lek > that includes
the disease to which it applies (Dk ), the set of relevant variables to the interaction (V k ), and an expression codifying
a single adverse interaction (lek ) to be added to the logical
model. A revision operator is defined as a 4-tuple <Dk , V k ,
slek , tlek > with a disease label (Dk ), variables appearing in
the adverse interaction (V k ), and modifications (slek , tlek )
to the logical model that should address this interaction. Operators can be applied to all diseases using a wildcard (∗) for
Dk , to a set of diseases, or to a single disease. For WPW and
AF we include two interaction operators (IO1 , IO2 ) and one
revision operator (RO1 ) applicable to both diseases:
&%
$'"'
Figure 4: Modified AGexp
WPW
a sequence of 3 forward paths. The acyclic actionable graph
(AGexp
W P W ) obtained after applying the expand procedure is
shown in Figure 4.
Numerical variables need special attention when creating logical models and they affect both how action and decision variables are used. In the case of action variables,
numerical variables add support for actions that are more
complex than “go/no go” flags. For example, where a variable representing the administration of flecainide was previously represented by a binary variable F := true/f alse in
our logical model, introducing a numerical variable DF :=
[0 . . . 500] enables considering both administration of a medication and an associated dosage (medication is administered
if its dosage is greater than 0).
Numerical variables also allow for algebraic expressions
that define conditions and they enable the computation of
values for these variables. Logical models can have expressions such as ¬(A ∧ DFsaf e (P )) ∧ (DF = DF 1 + DF 2 +
DF 3 + . . .), flexibility that is especially important in mod-
IO1 = <{WPW, AF}, {A, DF}, {(A ∧ (DFsaf e (P))}>
IO2 = <{WPW, AF}, {DF, FIV}, {FIV ∧ (DFsaf e (P))}>
RO1 = <{WPW, AF}, {A, DF}, {DFsaf e (P)},
{DF = 0.75 ∗ DFsaf e (P)}>
The interaction operators describe indirect interactions between the maximum oral dosage of flecainide
1
2
50
plato.asu.edu/bench.html
www.eclipseclp.org
(DFsaf e (P ) = 200mg, coming from AGexp
W P W ) and oral
amiodarone (IO1 ) or intravenous flecainide (IO2 ). In these
two situations the toxicity of flecainide is exacerbated,
which would result in harm to the patient by exceeding acceptable levels of flecainide in plasma. Both operators are
used during the last phase of the mitigation algorithm to
enrich the CLP-CPG model for AF and WPW by adding
logical expressions to ILEW P W,AF . The revision operator RO1 reduces the dosage of flecainide from the maximum safe level (DFsaf e (P )) to 75% of this safety threshold (as described in Section 3). It revises the combined logical model by replacing all occurrences of (DFsaf e (P ))
with (DF = 0.75 ∗ DFsaf e (P )) in all expressions from
P LEW P W and P LEAF thus effectively lowering the current dosage of flecainide.
We use the ECLi P S e system to represent and solve a
CLP-CPG model and to identify violated constraints if no
solution exists. We chose ECLi P S e due to its repair library that enables easily monitoring constraints and retrieving a set of conflicting ones. When a constraint falls into
a conflict (i.e., when it is violated given the assignment of
values to the variables), it appears in a conflict set. The conflict set is used to identify constraints associated with direct
and indirect adverse interactions and below we show sample
ECLi P S e Prolog for monitoring indirect adverse interactions as defined by the IO1 operator. The first line defines
predicate for IO1 and creates a convict set to monitor while
the second line defines the lek expression for IO1 . Note that
in all interaction operators lek is negated, so the constraint
is violated as soon as the interaction occurs:
time the conflict set is empty (Conflicts = []). Subsequently,
ECLi P S e reports success and produces the following solution: [WS0 = n, WS1 = n, WS2 = n, DF0 = 50, DF1
= 100, DF2 = 150, DF3 = 200, DF= 150, HI = y, EC =
true, RAE = y, PD = true] that represents a combined therapy. In layman’s terms this solution indicates that the dosage
of flecainide is set to 150mg (DF = 150) as indicated by
the revision operation, the patient undergoes electrical cardioversion (EC = true) and is discharged (P D = true)
afterwards. This therapy has been confirmed as valid by the
medical experts on our team.
Now consider a patient without hemodynamic instability
(HI = n), no structured heart disease (HD = n), no recurring
AF (RAE = n) who has not stabilized within the first three
rounds of flecainide (WS0 = WS1 = WS2 = n). This time
interaction operator IO2 appears in the conflict set because
flecainide must be administered intravenously according to
the AF guideline. However, there is no knowledge codified
as a revision operator to suggest a revised action (RO1 codifies interactions between amidarone and flecainide only).
Therefore ECLi P S e is unable to find a solution and it reports failure together with the possible source of infeasibility
(a set of two variables - FIV and DF). At this point it is up
to the physician to determine the correct next steps given the
patient information available to them.
5
Towards a Formal Theory for Mitigation
With the support of an illustrative clinical scenarios, we
demonstrated how our proposed algorithm can automate the
process of identifying interactions between guidelines with
iterative actions and numerical variables. However, in practice fixing the number of iterations in advance may not work
as typically the number of iterations are decided at the point
of care and adjusted over time. Additionally, clinical practice calls for the relaxation of other assumptions we make,
including: (1) a restricted number of guidelines considered,
two in our case; (2) no direct support of concurrency, time,
uncertainty; (3) exclusion of sub-guidelines. For a comprehensive approach to removing these restrictions, it is necessary to extend our CLP-based model to include a foundational framework. At the heart of such a framework lies
the principles for formally characterizing the notion of iterations and ideally all critical attributes (such as concurrency,
time, interrupts and reactions, sub-components, uncertainty,
and even trust) that are needed to fully describe primary or
secondary knowledge for the mitigation of guidelines.
Available logical frameworks with enough expressive
power for this characterization task include Situation Calculus (Reiter 2001), Event Calculus (Mueller 2009), and Fluent Calculus (Thielscher 1998). Considering these options,
Situation Calculus presents itself as a intriguing option. First
introduced in (McCarthy 1963), Situation Calculus is a logic
formalism designed for representing and reasoning about actions and change in dynamic domains. It provides the theoretical foundations for representing actions and their effects
along with concise and mathematically rigorous implementations for reasoning about these actions and effects. Additionally, a set of constructs (e.g., tests, sequences, iterations
1 interaction1(A, DF, DFsafe) r_conflict cs,
conflict_constraints(cs, Conflicts).
2 interaction1(A, DF, DFsafeP):(A and (DF $= DFsafeP)) $= 0.
For the first clinical scenario consider a patient who has
not been stabilized within the first three rounds of flecainide
(WS0 = WS1 = WS2 = n), has hemodynamic instability
(HI=y), and who has a reoccurrence of AF (RAE = y). Given
the CLP-CPG model and an initial assignment of values to
variables as defined by the above patient information, the
mitigation algorithm invokes ECLi P S e . No direct adverse
interactions are detected (Phase 2 of the mitigation algorithm) so the CLP-CPG model is augmented with interaction
operators IO1 and IO2 (Phase 3) and ECLi P S e is again
invoked. This time, it returns the following system message
when trying to solve the augmented model:
Conflicts = [interaction1(1, 200, 200)]
This message guides the mitigation procedure (and is not
intended to be read by humans), indicating an adverse indirect interaction has been detected corresponding to IO1
(interaction1 in the message), and the mitigation algorithm
proceeds to resolve this interaction by invoking the revision operator RO1 that lowers the dosage of flecainide from
DFsaf e (P ) to 0.75∗DFsaf e (P ) (given P = 0.7, this translates to lowering from 200mg to 150mg). We note that details for determining which revision operators are relevant to
identified interactions are given in (Wilk et al. 2013). The revised model is passed to ECLi P S e and solved again. This
51
and choices) can be conveniently built on top of the Situation Calculus. Using these constructs, primitive actions in
a given domain can be assembled into complex ones which
can further be executed and analyzed.
These features of the Situation Calculus naturally enable
it as a foundational formalism for handling many of the issues that arise in our current approach for mitigating guidelines and as such we are investigating how to use it to create
a formal theory for mitigation. Our initial research looks at
transforming graphically represented guidelines (we are currently using actionable graphs) to instances of a basic action
theory (BAT) for graphical formalisms in the Situation Calculus. A BAT for a particular domain is a set composed of
domain-independent foundational axioms, action precondition axioms for the primitive actions in the domain, successor state axioms for the fluents in the domain, unique name
axioms, and axioms for the initial situation.
Alternatively, guidelines can be represented graphically
as Petri nets (Beccuti et al. 2009), a graphical modeling
language for complicated concurrent processes. Using Petri
nets could provide us access to SCOPE (Situation Calculus
Ontology of PEtri nets) (Tan 2010), a BAT for Petri nets,
and subsequently TESCOPE (Tan 2012), a theory that extends SCOPE with the concept of time. Mitigating multiple
guidelines for viable solutions thus could be transformed
into writing (TE)SCOPE-based complex actions and analyzing their executability. The high-level Golog language is
available for use with SitCal. Finally, since business workflow based representational systems such as BPMN are also
widely used in representing CPGs (e.g., SAGE (Tu et al.
2007)), adopting BPMN as the graphical counterpart for our
foundational framework will also be investigated.
6
suggested and thus trust the results. We are starting to design
interface components that will be used to highlight any point
of infeasibility detected and how they were handled, with explanations for mitigation choices taken from evidence-based
repositories such as the Cochrane Library.
References
Beccuti, M.; Bottrighi, A.; Franceschinis, G.; Montani, S.; and
Terenziani, P. 2009. Modeling clinical guidelines through petri
nets. In AI in Medicine. Springer. 61–70.
Boyd, C.; Darer, J.; Boult, C.; Fried, L.; Boult, L.; and Wu, A.
2005. Clinical practice guidelines and quality of care for older
patients with multiple comorbid diseases: implications for pay for
performance. JAMA 294:716–24.
Fox, J.; Glasspool, D.; Patkar, V.; Austin, M.; Black, L.; South, M.;
Robertson, D.; and Vincent, C. 2010. Delivering clinical decision
support services: there is nothing as practical as a good theory. J
Biomed Inform 43:831–43.
Hing, M.; Michalowski, M.; Wilk, S.; Michalowski, W.; and Farion, K. 2010. Identifying inconsistencies in multiple clinical practice guidelines for a patient with co-morbidity. In Proceedings of
KEDDH-10, 447–452.
Isern, D., and Moreno, A. 2008. Computer-based execution of
clinical guidelines: a review. J Med Inform 77:787–808.
Latoszek-Berendsen, A.; Tange, H.; van den Herik, H.; and Hasman, A. 2010. From clinical practice guidelines to computerinterpretable guidelines. a literature overview. Methods Inf Med
49:550–70.
McCarthy, J. 1963. Situations, actions, and causal laws.
Mueller, E. T. 2009. Automating commonsense reasoning using
the event calculus. Commun. ACM 52(1):113–117.
Reiter, R. 2001. Knowledge in action: logical foundations for
specifying and implementing dynamical systems. Cambridge, MA,
USA: MIT Press.
Sittig, D.; Wright, A.; Osheroff, J.; Middleton, B.; Teich, J.; Ash,
J.; Campbell, E.; and Bates, D. 2008. Grand challenges in clinical
decision support. J Biomed Inform 41:387–92.
Tan, X. 2010. SCOPE: A Situation Calculus ontology of Petri nets.
In Galton, A., and Mizoguchi, R., eds., 6th International Conference of Formal Ontology in Information Systems, Toronto, Canada,
227–240.
Tan, X. 2012. Go beyond the SCOPE: A Temporal Situation
Calculus-based Software Tool for Time Petri Nets. In International
Conference on Industrial Engineering and Other Applications of
Applied Intelligent Systems, 134–143.
Tarjan, R. 1972. Depth-first search and linear graph algorithms.
SIAM Journal on Computing 1:146–160.
Thielscher, M. 1998. Introduction to the fluent calculus. Electron.
Trans. Artif. Intell. 2:179–192.
Tu, S. W.; Campbell, J. R.; Glasgow, J.; Nyman, M. A.; McClure,
R.; McClay, J.; Parker, C.; Hrabak, K. M.; Berg, D.; Weida, T.; et al.
2007. The sage guideline model: achievements and overview. Journal of the American Medical Informatics Association 14(5):589–
598.
Wilk, S.; Michalowski, W.; Michalowski, M.; Farion, K.; Hing, M.;
and Mohapatra, S. 2013. Automatic mitigation of adverse interactions in pairs of clinical practice guidelines using constraint logic
programming. J Biomed Inform 46(2):341–353.
Discussion
In this paper we presented our mitigation algorithm. In order to operationalize the extended algorithm we rely on a
number of methodologies. First, we use methods to identify
a cyclic graph and we presented the expand procedure that
converts it into an acyclic one. In the next step we use logical
calculus as a method for developing logical models of CPGs
that form the core representation of the guidelines. These
models are subsequently converted into a CLP-CPG model
that is solved using a standard CLP solver (ECLi P S e ). Use
of these different methodologies is necessary in order to
address complexities associated with the development of a
therapy for comorbid patients. Finally, we briefly discussed
our initial work towards a formal theory for representing and
mitigating CPGs that will enable us to operationalize the application across a broad range of clinical scenarios.
Our next step is towards the goal of creating a comprehensive alerting system for physicians that will support the
concurrent application of multiple CPGs. Our mitigation algorithm is currently being incorporated into a mobile clinical decision support system called MET3 to create a proofof-concept application for evaluation in a clinical scenario.
Integration into this CDSS requires consideration of the human interface and clarity of results as it is crucial that humans can understand why changes in interventions are being
3
www.mobiledss.uottawa.ca/site/met.html
52