What-If Analyzer for DMN-based Decision Models Jacob Feldman OpenRules, Inc., 53 Riviera Dr., Monroe, NJ 08831, USA jacobfeldman@openrules.com Abstract. This paper describes a new web-based graphical tool “What-If Analyzer for Decision Modeling” that supports what-analysis of different business decision models created in accordance with the DMN standard. It allows a user to modify the decision model by activating/deactivating business rules that represent its decision logic, and immediately see changes in the decision variables. With a simple click it may produce and navigate through multiple decisions that satisfy all active rules within the same decision model. If the decision model specifies a business objective that depends on other decision variables, then What-If Analyzer may find optimal decisions that minimize or maximize this objective. What-If Analyzer is implemented as an advanced component of the popular open source business decision management system “OpenRules”. Keywords: Decision Modeling, Decision Optimization, DMN, Multiple and Optimal Decisions. 1 Introduction Five years ago we published a paper [1] that described how constraint solvers may serve as rule engines in the context of modern business rules and decision management systems. At that time we considered business decision models created based on the methodological approach described in the book “The Decision Model” [3]. Since then Object Management Group (OMG) has approved a new standard “Decision Model and Notation” (DMN) [2] that quickly gained popularity among decision management vendors, experts, and practitioners. The DMN standard covers more powerful and complex decision models to compare with [3]. In this paper we are applying the results of [1] to DMN-based decision models by presenting them as constraint satisfaction and optimization problems. We also describe a generic graphical interface that allows a user to do what-if analysis of such decision models finding multiple feasible decisions and optimal decisions which minimize/maximize certain business objectives. In section 2 we provide a formal definition of the DMN-based decision model as a constraint satisfaction and optimization problem. Section 3 describes a new OpenRules tool called “What-If Analyzer for Decision Modeling” [10] that utilizes constraint solvers to do real-time what-if analysis of decision models. This section demonstrates the major functionality of What-If Analyzer using decision models for two problems: a simple arithmetic problem and a loan origination example. Section 4 describes how What-If Analyzer has been implemented including the execution engines, graphical interface, and implementation restrictions. And finally, section 5 describes the related work and future development. 2 Decision Model as Constraint Satisfaction Problem Formally, a decision model is defined by a set of variables, X = { X1, X2,…, Xn }, and a set of rules, R = { R1, R2,…, Rm }. Each variable Xi has a nonempty domain Di of possible values. Each rule Ri defines relationships between different variables from a subset of X and specifies the allowable combinations of values for that subset. A decision is an assignment of values to all mentioned variables, { Xi=vi, Xj=vj, …}, that satisfies all the rules. The decision model can produce multiple decisions. Some decision models require a decision that minimizes/maximizes an objective function, which usually depends on some variables. This representation demonstrates that the Decision Model is quite similar to the classical definition of CSP – see for example Russel and Norvig [4] where a decision variable Xi corresponds to a constrained variable and where a rule Ri corresponds to a constraint. In [1] we had shown how a decision model created in accordance with the methodological approach [3] can be reformulated is a special case of CSP with using mainly conditional constraints. As the DMN standard [2] extends decision modeling functionality beyond [3], we need to extend the results of [1] to handle DMN-based decision models. In particular, the DMN standard along with simple single-hit decision tables allows multi-hit decision tables with various hit policies and aggregation methods. It introduced a special expression language “FEEL” that includes loops, indexes, and invocation of external functions. These new constructs may lead us beyond conditional constraints and we will need to show precisely how each of them can be implemented within a constraint satisfaction environment. This paper describes a new tool that automatically converts DMN-based decision models to constrained satisfaction and optimization problems and provides a user-friendly graphical interface to modify and analyze them. However, as the majority of the current DMN implementations [5] do not cover (at least yet) advanced DMN concepts, this paper considers only basic DMN-based decision models without multi- hit tables and complex FEEL expressions. 3 What-If Analyzer for Decision Modeling “What-If Analyzer for Decision Modeling” [10] is a stand-alone web application built on top of OpenRules [6]. Its main purpose is to support what-if analysis of DMN- based decision models. What-if analysis is the process of changing business rules that represent business logic to see how these changes affect the outcome of the decision model. What-If Analyzer functionality includes:  Downloading a DMN-based decision model  Showing it graphically by presenting the current state of all decision variables and all business rules  Activation/Deactivation of different rules and with an immediate propagation of these actions by displaying changes in the domains of affected decision variables.  Finding a feasible solution that satisfies all currently active rules  Finding and navigating through multiple feasible solutions  Finding optimal solutions for the defined business objectives. What-If Analyzer comes with a collection of DMN-based decision models from different domains including loan origination, scheduling and resource allocation, and 1 some interesting decision models offered as DMCommunity,org challenges . A user may select these models from the combo-box “Select Decision Model” and start their real-time what-if analysis: New custom decision models can be easily added to the tool. We will demonstrate various capabilities of the What-If Analyzer using two sample decision models:  A simple arithmetic decision model  A loan origination decision model. 1 https://dmcommunity.wordpress.com/challenge/ 3.1 Analyzing Simple Arithmetic Decision Model First, let’s consider a simple decision model that deals with only 4 decision variables and various arithmetic constraints defined on them. Here is a sample of its graphical view: This decision model was downloaded from Excel-files which presented it in accordance with the OpenRules [6] format. On the left you may see 4 decision variables X, Y, Z, and Objective that were initially defined in the following Excel- based glossary: On the right you can see all rules (active and not) collected from decision tables which were initially defined in Excel-based as follows: When a user activates the rule “Z > 5” by checking the proper flag in the table “Business Rules”, the Analyzer immediately modifies the domain of all affected variables in the table “Decision Variables” on the left. If we deactivate this rule and try to activate the rule “Z < 5”, the analyzer immediately will point us to the conflict: This way the Analyzer constantly checks consistency of the entire decision model: it is trying to find conflict among all (!) active rules. It means the Analyzer considers conflicts not only within one decision table but across all decision tables – a functionality that was out of reach for the majority of consistency validation tools. When a user pushes the button “Solution”, the analyzer will find and show the first feasible solution that satisfies all currently active rules. A user may push buttons “Next” and “Prev” to find and navigate through the various feasible solutions: This decision model specifies an objective using the rules (Objective = X*Y-Z). So, the Analyzer may find an optimal solution that minimizes or maximizes this objective: A user may "Deactivate All Rules" and start activating various rules one-by-one and analyzing their contribution to the removal of certain values from the domains of decision variables. Actually a user of What-If Analyzer has an ability to emulate various rules execution modes usually available to only rule engine developers (such as backward-chaining when we activate constraints on the objective). 3.2 Analyzing Loan Origination Decision Model Loan origination process is frequently used as a typical example of decision modeling. Initially we took a loan-prequalification decision model described at the 2 DMCommunity website . Being downloaded at the What-If Analyzer, it looks as follows: 3 (click on the image to enlarge it ) 2https://dmcommunity.wordpress.com/decision-models/financial-services/loan-pre- qualification/ 3 http://openrules.com/Site/images/WhatIfLoan.jpg In this example a borrower provides the requested loan amount, loan term and her personal info financial information as an input, and the decision model produces one of two possible decision outputs: - the borrower is qualified for the loan - the borrower is not qualified for the loan with an explanation. While this model will be successfully executed by the Analyzer, it does not provide the flexibility to keep the borrower interested even when an initial loan request is rejected. It would be much more beneficial if the decision model can also recommend how to modify the loan request (e.g. decrease loan amount or increase loan term) to still make the borrower qualified. Below we will consider a modified decision model that allows a loan officer to consider different borrowing options using the What-If Analyzer. To do that, we will consider Loan Amount and Loan Term as unknown decision variables which should belong to the output of our decision model. Then Total Income and Total Debt also become unknown, e.g. Total Income = Monthly Income * Loan Term. For simplicity we will consider that Income Validation Results is SUFFICIENT if the Total Income exceeds Accumulated Debt, that is the sum of the total loan amount and the total debt over the selected loan term. The actual income validation rules are defined in the following Excel-based decision table: We also added several rules that will allow us to define different constraints on loan amount and loan term. The complete representation of the decision model can be 4 5 6 7 found in these Excel files: Decision.xls , Rules.xls , Glossary.xls , and Data.xls . Now let’s consider how the What-If Analyzer can represent our decision model using its graphical interface. Being downloaded into the What-If Analyzer, our decision model will look as follows: 4 http://openrules.com/xls/LoanCalculation/Decision.xls 5 http://openrules.com/xls/LoanCalculation/Rules.xls 6 http://openrules.com/xls/LoanCalculation/Glossary.xls 7 http://openrules.com/xls/LoanCalculation/Data.xls As you can see, on the loan request here is converted into two active rules: - Loan Amount = 50000 - Loan Term = 24 (months) Please note that we added a rule (the last one) that enforces Income Validation Result to be SUFFICENT. The What-If Analyzer immediately produces a conflict as the last rule contradicts to income validation rules. To avoid this conflict while still keeping Income Validation Result = SUFFICIENT, we may deactivate the rule “Loan Amount = 50000” leaving Loan Amount being between 35000 and 75000. Here is the resulting view: Now the conflict is resolved, and the decision variable “Loan Amount” is bounded to 35000..35999 as defined by a pure propagation of the rule deactivation event. It is interesting to see that the maximal loan amount is now 35999 that can be explained by the automatically propagated rule “Loan Term = 24”. To increase the maximally allowed Loan Amount we may try to increase Loan Term. Let’s deactivate the rule “Loan Term = 24” but activate the rule “Loan Term <= 36”. When we click on the button “Solution”, the Analyzer will quickly find the first feasible solution, and then we may click to the buttons “Next” and “Prev” to navigate through multiple solutions. For example, after 28 clicks on the button “Next” the Analyzers will show a solution # 28 out of 500. Actually the Analyzer may find much more feasible solutions if we change the limit “500” using the Analyzer’s button “Settings”. Here is the solution#28: When the total number of solutions is relatively small it may be useful for a user to manually navigate through different solutions. However, it would be too tedious or even impossible to do that. Instead, we may simply click on the button “Maximize” and the Analyzer (after a 30-40 seconds delay) will find the maximal Loan Amount. Of course, the search of an optimal solution for some models may become a large NP- hard problem that may take from a few minutes or be interrupted by configurable time limits (available through the button “Settings”). Here is a list of all decision variables with values which correspond to the optimal decision that maximizes Loan Amount: So, the maximal Loan Amount is $53,999 while selected the Loan Term is 36. Similarly, we may continue to deactivate and activate other limits to find various optimal combinations of Loan Amount and Loan Term while satisfying other active loan origination rules. 4 Implementation Execution Engines. What-If Analyzer has been built on top of OpenRules Engine known as “Rule Solver” [7]. Rule Solver is capable to download OpenRules decision model directly from Excel files and automatically generate the corresponding constraint satisfaction and optimization problem. Rule Solver is based on the standard Java Constraint Programming API defined by the Java Specification Request (JSR) 331 [8]. The use of the JSR 331 allows a user not to commit to a particular CP vendor and to try different compliant solvers before choosing the most suitable one based on its technical and business applicability. With this approach, we may switch between different underlying CP solvers compliant with the JSR 331 without any changes in the code. Performance. For the majority of the already tried decision models, What-If Analyzer demonstrates a high performance supporting real-time what-if analysis of decision models. The results of rules activation/deactivation are propagated within seconds. The search of feasible solutions is usually also does not create any performance problems: as was shown in [1] the performance of the underlying constraint solvers is usually better when being compared with traditional rule engines. In the majority cases, decision models executed with traditional rule engines do not even consider multiple or optimal decisions. What-If Analyzer opens the door to business analysts to redefine their decision models in the way that they can navigate through multiple decisions and even find optimal decisions. However, when it comes to search of optimal decisions, a user should be warned about potential performance issues. It is quite possible to redefine decision models by relaxing some rules that may lead to situations when a number of possible combinations for all decision variables grows exponentially (as we demonstrated on the loan calculation example with a 30- 40 seconds delay while maximizing the loan amount). In such cases, the underlying constraint optimization problem becomes NP-complete and possible cannot be resolved within reasonable time interval. To address these problems What-If Analyzer sets the default limits for: - the total number of considered solutions - execution time for a search of one solution - execution time for the overall search. These limits can be adjusted and saved for every particular decision model using the button “Settings”. It allows a decision model designer to find up a reasonable compromise between the allocated time and quality of the proposed decision. Looking for an optimal decision, What-If Analyzer relies on the default search strategy provided by OpenRules Rule Solver [7]. However, for industrial level decision models a search of optimal decisions may require a modeler to redefine the search strategies by adding more sophisticated search heuristics. Graphical Interface. The graphical interface for the Analyzer has been built using OpenRules Dialog [9] that provides a simple rules-based environment for building web applications. We recognize that one universal graphical interface cannot satisfy all decision models that in real-world may require a lot of application-specific features. So, the choice of OpenRules Dialog allows a user to essentially customize the graphical interface of What-If Analyzer without major changes in the underlying logic. Implementation Restrictions. The current implementation of What-If Analyzer supports decision models created in accordance the methodological approach described in [1] and extended to the new DMN standard. However, currently it does not support multi-hit decision tables and aggregation functions allowed by the DMN standard [2]. It also supports only basic constructs of the DMN FEEL language and provides its own facilities for various constrained expressions implemented within Rule Solver. In spite of these implementation restrictions, What-If Analyzer covers a wide class of practical decision models in different business domains, and empowers users with features that were out of reach for the majority of business rules and decision management systems. 5 Related Work and Future Development What-If Analyzer for Decision Modeling provides unique features which so far were out of reach for the majority of business rules and decision management systems. However, a similar functionality was available for constraint-based environments oriented to more technical users. In particular, in [11] we described practical design patterns for constraint programming including the “Consistent Constrained Core” pattern that is very similar to how What-If Analyzer execution engine has been implemented. And in [12] we demonstrated how this pattern was applied to scheduling and resource allocation problems. Of course, these systems dealt directly with constraint satisfaction problems and did not include the proper transformation of business oriented decision models. In the future, we plan to remove the implementation restrictions described above. It will require finding a new constraint-based approach to implementation of multi-hit decision tables with various aggregation functions. It will probably lead us far beyond of conditional constraints described in [1]. For example, even simple rule overrides already require a new approach as we cannot simply assign a new value to already instantiated decision variables within a constraint satisfaction environment as it will lead to a failure. Even more complicated issues to consider are the situations when a decision table is accumulating different values inside one decision variable using compound assignment operators such as “+=”. In such situations, we would probably need to accumulate all conditional assignments in an intermediate array before applying them to the resulting decision variable. We would also need to consider a converter from DMN FEEL expressions to constrained expressions using JSR-331. All these consideration considerations will be a subject for additional R&D. The latest version DMN 1.1 specifies an interchange format in XML. It will allow decision models produced by one DMN supporting tool to be exported to a DMN XML file, and then to be imported by another DMN supporting tool. In particular, it will allow What-If Analyzer to work with DMN-based decision models produced by other tools. References 1. J.Feldman: Representing and Solving Rule-Based Decision Models with Constraint Solvers, in Proc. of RuleML 2011 - America, LNCS 7018, pp. 208-221, 2011, Springer-Verlag Berlin Heidelberg 2011,http://www.springerlink.com/content/e66077u456548231 2. Decision Model and Notation™ (DMN™), Object Management Group (OMG), http://www.omg.org/spec/DMN/Current 3. B. von Halle, L.Goldberg: The Decision Model: A Business Logic Framework Linking Business and Technology. Auerbach Publications/Taylor & Francis Group, LLC (2009) 4. S.Russell, P.Norvig: Artificial intelligence: a modern approach, Third Edition, http://aima.cs.berkeley.edu/2nd-ed/newchap05.pdf 5. DMN Supporting Tools, Decision Management Community, http://DMCommunity.org, http://openjvm.jvmhost.net/DMNtools 6. OpenRules, Open Source Business Rules and Decision Management System, http://openrules.com 7. OpenRules Rule Solver, http://openrules.com/rulesolver.htm 8. Java Request Specification (JSR) 331: Constraint Programming API. Java Community Process, http://www.jcp.org/en/jsr/detail?id=331 9. OpenRules Dialog – a Questionnaire Builder, http://openrules.com/ord.htm 10. What-If Analyzer for Decision Modeling, http://openrules.com/WhatIfAnalyzer.htm 11. J. Feldman, D. Vergamini: Practical Patterns for Constraint Programming, PACP-98, 1998, London, http://openrules.com/presentations/pact98.pdf 12. J. Feldman: Interactive Constraint Propagation, INFORMS, November-1999, Philadelphia, http://openrules.com/presentations/INFORMS99.ppt