Ternary-Decimal Exclusion Algorithm for Multiattribute Utility Functions

Abstract

We propose methods to eliminate redundant utility assessments in decision analysis applications. We abstract a set of utility assessments such that the set is represented as a matrix of ternary numbers. To achieve efficiency, the matrix is converted to a decimal vector for further processing. The resulting approach demonstrates excellent performance on random sets of utility assessments. The method eliminates the redundant questions for the decision maker and can serve for consistency check.

1 Introduction

In multi-objective decisions under uncertainty, the decision maker’s trade-offs over the different attributes (e.g. increase output, but decrease expenses [1]) can be expressed through a multiattribute utility function (MUF). In complex decision problems, e.g. power plant siting [2,3,4], the construction of a MUF [5] becomes difficult with the number of attributes. For example, Keeney and Raiffa [6] discuss the siting of nuclear power facilities utilizing ten attributes while Keeney and Sicherman [7] model alternatives for generating electricity using 14 attributes. To simplify the assessment of a MUF from the decision maker [8], it can be decomposed into lower-order terms [9]. The lower-order terms of MUF may contain redundancies. The elimination of possible redundancy in utility assessments saves time significantly for the decision maker.

Although in different context, the task to eliminate redundant expressions in a program may arise in compiler optimization. The example of a redundant expression here could be a computation that is performed twice. Different algorithms have been discussed to address this problem [10,11,12]. Redundancy is also met in biomedical science. In particular, if some biological functions (or terms) in the gene ontology (GO) hierarchy do not provide additional information, then they are redundant and must be excluded from the GO lists [13].

In this paper, we consider the problem of determining the minimal set of utility assessments (lower-order terms) needed to construct a MUF from a given set of assessments. We introduce a novel and efficient method for eliminating duplicate and redundant terms in a MUF. The efficiency of the method is achieved by transferring the computational burden from a two-dimensional input (ternary matrix) to a decimal vector. The algorithm sorts the vector, eliminates possible duplicates and redundancies, and returns the unique set of utility assessments. The method can help to exclude redundant questions for the decision maker. It can also be used to check the consistency of the utility assessments, which are required for a construction of multiattribute utility functions.

2 Preliminaries

Consider a decision problem with a set of $n$ attributes $X = \left\{ {X_{1} ,X_{2} , \ldots ,X_{n} } \right\},$ where the domain of the attribute $X_{i}$ is represented by instantiations: $x_{i}^{0} ,x_{i}^{*} ,x_{i}^{{}} ,$ such that the former two are the subsets of the latter and distinct. Namely, $x_{i}^{0}$ and $x_{i}^{*}$ are the least and most preferred values of attribute $X_{i} ,$ and $x_{i}^{{}}$ denotes all values. Let $U = \left\{ {U_{1} ,U_{2} , \ldots ,U_{m} } \right\}$ be a given set of utility assessments, where $U_{j}$ is a function of $X.$ The goal is to return $U$ without redundant assessments.

For example, consider the five utility assessments presented in Fig. 1(a). The first two terms, $U(x_{1}^{{}} ,x_{2}^{{}} ,x_{3}^{0} ,x_{4}^{0} )$ and $U(x_{1}^{*} ,x_{2}^{{}} ,x_{3}^{{}} ,x_{4}^{0} ),$ are redundant due to the terms $U(x_{1}^{{}} ,x_{2}^{{}} ,x_{3}^{0} ,x_{4}^{{}} )$ and $U(x_{1}^{*} ,x_{2}^{{}} ,x_{3}^{{}} ,x_{4}^{{}} ),$ respectively. The fifth term is a duplicate of $U(x_{1}^{*} ,x_{2}^{{}} ,x_{3}^{{}} ,x_{4}^{{}} ).$ Therefore; a unique set of utility assessments will contain only two terms.

Fig. 1.

(a) Utility assessments; (b) Ternary matrix $M.$

To simplify the encoding and decoding of utility assessments, Abdildin and Abbas [14] introduced the ternary matrix of utility assessments, so that the given set can be encoded as a $5 \times 4$ ternary matrix $M$ as shown in Fig. 1(b).

Definition 1

[14]. The ternary matrix of utility assessments, $M,$ is an $m \times n$ matrix storing integers 0, 1, and 2, representing respectively the least preferable value, the most preferable value, and all values of an attribute, where $m$ is the number of utility assessments, and $n$ is the number of attributes of the decision-making problem.

To eliminate duplicate and redundant terms from the ternary matrix $M$ in a brute-force approach, every row of $M$ has to be compared with all other rows elementwise. The brute-force approach can be implemented in different ways, the pseudo-code of the one utilized in this paper is given in the appendix. Another approach [14] is to compare only parts of the rows called twos-complement. The twos-complement part represents the set of columns in a row containing ones and zeros, i.e. complements of twos. We now propose a novel and more efficient approach for eliminating redundant utility assessments.

3 Proposed Approach

3.1 Main Idea

The main idea of the ternary-decimal exclusion algorithm [15] can be described by small example when $n = 2.$ In this case, the nine values of the ternary number, T, can vary from [0 0] to [2 2] (see Table 1).

Table 1. Coverage table for n = 2.

We can observe that:

• If ternary number [2 2] exists in the input matrix (or $max = 3^{n} - 1 = 8$ in decimal), then all other numbers must be excluded from the ternary matrix.

• If ternary number [2 1] (or $max - 1 = 7$ in decimal) is present, then decimal numbers 1 and 4 can be eliminated (note, a modulo 3 division (%) returns the remainder 1). Similarly, 6 covers 0 and 3, because, for example, 6 % 3 = 0.

• The decimal 2 covers all numbers below it and 5 covers 3 and 4.

• In addition, 2 and 5 divide the decimal numbers into three sub-intervals of equal length.

Therefore, we will convert the input ternary matrix $M(m,n)$ into a decimal vector $V(m),$ sort the vector, eliminate duplicate numbers, and then (recursively) eliminate redundancies using the observations discussed above. The recursion utilized in the proposed approach improves the performance of the algorithm. It recursively divides the sorted vector into three sub-vectors using the right bounds: $lb = \left\lfloor {min + (max - min)/3} \right\rfloor$ and $mb = \left\lfloor {min + 2(max - min)/3} \right\rfloor ,$ for the left and mid sub-vectors, respectively, where initially $min = 0$ and $max = 3^{n} - 1.$

Note that the ternary numbers in Table 1 are unique and their number grows fast with $n.$

Definition 2.

For a decision problem with $n$ attributes, the cardinality of the ternary matrix of utility assessments is the total number of possible unique ternary numbers that it can contain and is equal to $3^{n} .$

So, the amount of unique ternary numbers (i.e. utility assessments) that can be formed from the rows of matrix $M(m,n)$ is limited by its cardinality. The cardinality of the ternary matrix of utility assessments will be used later in our simulations.

3.2 Pseudocodes

The algorithm consists of the following steps. First, we convert the ternary matrix $M(m,n)$ to a decimal vector $V(m).$ Recall, a $d$-digit ternary number, $T,$ can be converted to a decimal as follows: $D = t_{d} R^{d} + t_{d - 1} R^{d - 1} + \ldots + t_{1} R^{1} + t_{0} R^{0} ,$ where $R$ denotes radix (base 3), and $t_{d}$ denotes the digits of $T .$ As an example, $T = 102$ in decimal is $D = 1 * 3^{2} + \, 0 * 3^{1} + { 2} * 3^{0} \,{ = }\, 1 1.$

Next, we sort the decimal vector $V(m)$ and eliminate duplicates. One can use any efficient algorithm (see comparisons in [16]) to sort the decimal vector and then eliminate the duplicates in linear time.

Then, we recursively exclude redundancies from the vector. The pseudocode of the subroutine is presented in Table 2. A modulo division is denoted by %, an empty vector by [], and elements of vector $V$ from 1 to idx by V(1:idx). The procedure uses the subroutine (Table 3).

Table 2. Pseudocode of the subroutine.

Table 3. Pseudocode of the subroutine.

Now, we convert the decimal vector to the ternary matrix. Recall, a decimal number $D$ can be converted to a ternary $T$ by continually dividing $D$ by three to have a quotient and a remainder until the former is equal to zero. Then the remainder is read in a reverse order.

Complex interdependence conditions in a decision problem may lead to specific redundancies in utility assessments. The last step of the proposed algorithm, subroutine (Table 4), is needed to eliminate such redundancies.

Table 4. Pseudocode of the subroutine.

3.3 An Illustrative Example

Let us consider a three-attribute decision problem in which attributes $X_{1}$ and $X_{2}$ are utility independent [6] from attribute $X_{3} ,$ and attribute $X_{3}$ is utility independent from attributes $X_{1}$ and $X_{2} .$ These partial utility independence conditions imply that:

• $U(x_{1}^{{}} |x_{2}^{{}} ,x_{3}^{{}} ) = U(x_{1}^{{}} |x_{2}^{{}} ,x_{3}^{0} )$

• $U(x_{2}^{{}} |x_{1}^{{}} ,x_{3}^{{}} ) = U(x_{2}^{{}} |x_{1}^{{}} ,x_{3}^{0} )$

• $U(x_{3}^{{}} |x_{1}^{{}} ,x_{2}^{{}} ) = U(x_{3}^{{}} |x_{1}^{0} ,x_{2}^{0} ).$

The multiattribute utility function (MUF) can be decomposed into lower-order terms by expanding it through the attributes, which present some utility independence. For example, the expansion of a MUF [9, 14] through the first attribute leads to the following functional form: $U(x_{1}^{{}} ,x_{2}^{{}} ,x_{3}^{{}} ) = U(x_{1}^{*} ,x_{2}^{{}} ,x_{3}^{{}} )U(x_{1}^{{}} |x_{2}^{{}} ,x_{3}^{{}} ) + U(x_{1}^{0} ,x_{2}^{{}} ,x_{3}^{{}} )\bar{U}(x_{1}^{{}} |x_{2}^{{}} ,x_{3}^{{}} ),$ where $\bar{U}(x_{1}^{{}} |x_{2}^{{}} ,x_{3}^{{}} ) = 1 - U(x_{1}^{{}} |x_{2}^{{}} ,x_{3}^{{}} ).$ A further expansion of the MUF through the remaining two attributes and incorporation of the partial utility independence conditions (see details in [9, 14]) will result in the functional form with multiple lower-order terms some of which are duplicate or redundant.

The utility terms arising from the decomposition of the MUF for this decision problem can be encoded as an input ternary matrix for our algorithm (see Fig. 2). Here, the input matrix is converted to a decimal vector (#1), the vector is sorted, and duplicates are eliminated (#2), redundancies are excluded (#3), and the vector is converted to a ternary matrix, which is then returned as an output (#4-5-Output). The output represents the five terms, which are required for construction of the multiattribute utility function, namely, $U(x_{1}^{{}} ,x_{2}^{{}} ,x_{3}^{0} ),$ $U(x_{1}^{*} ,x_{2}^{*} ,x_{3}^{*} ),$ $U(x_{1}^{*} ,x_{2}^{0} ,x_{3}^{*} ),$ $U(x_{1}^{0} ,x_{2}^{*} ,x_{3}^{*} ),$ $U(x_{1}^{0} ,x_{2}^{0} ,x_{3}^{{}} ).$ These utility terms should be assessed [8] from the decision maker. Thus, the proposed algorithm eliminates redundant questions for the assessor.

Fig. 2.

Illustration of the proposed algorithm on a three-attribute decision problem.

4 Simulation Results

The simulation results demonstrate very good performance of the proposed algorithm compared to the brute-force approach. The simulations were done in MATLAB R2017b on a machine with 8 GB of RAM and Intel(R) Core(TM) i5-6400 CPU @2.70 GHz 2.71 GHz under Windows 10 Enterprise. Figure 3 illustrates performance of the proposed algorithm relative to the brute-force approach for different numbers of functions (utility terms) and fixed number of attributes for 10,000 runs of randomly generated input ternary matrices. The average running times of the brute-force approach were set to unit. Comparing to the brute-force approach, the ternary-decimal exclusion algorithm demonstrates excellent performance for various values of m for a fixed value of n.

Fig. 3.

Performance of the ternary-decimal exclusion algorithm (TD) relative to the brute-force approach (BF) for different numbers of functions.

The proposed algorithm also shows very good performance for different values of n (see Fig. 4). Note that the value of m is proportional to n in this test and is equal to half of the cardinality of the ternary matrix. One limitation of the proposed approach is the case when m is disproportionately very low for a given n. For example, if $m\, < \,floor(0.05(3^{n} )),$ then the efficiency of the proposed approach decreases. This gives a motivation for future work.

Fig. 4.

Performance of the ternary-decimal exclusion algorithm (TD) relative to the brute-force approach (BF) for different numbers of attributes.

5 Conclusion and Future Work

For solving problems under uncertainty, the decision maker often must consider many factors and use multiple criteria (i.e. attributes). The construction of a multiattribute utility function, in this case, may require assessments of various lower-order utility terms. The exclusion of utility terms, which are duplicate or redundant, can be quite challenging in complex decision problems.

This paper introduced a novel method for excluding redundant terms in a multiattribute utility function. The ternary-decimal exclusion algorithm demonstrated excellent performance on random sets. Future work may extend the analysis and possibly find better recurrence relations. The proposed algorithm can be used in decision support systems and can serve as a consistency check for the utility assessments.

Appendix

See Table 5.

Table 5. Pseudocode of the approach.