TABLA 85 Estadísticos de Grupo

We start our discussion with a concrete example. We are given an array ofN numbers (v₁, v₂, . . . , v_N), and our task is to pick the largest one. We solve this problem by checking the numbers one by one in any order, always comparing the current value against the largest seen so far. It is easy to see that this algorithm takes O(N) time and O(logN) space if we assume that each comparison is done in a single computational step and that the indices are represented using⌈logN⌉bits. The time-space complexity of this algorithm is O(NlogN).

From an information-theoretic point of view, this algorithm transforms the knowl-edge state about the maximum. Figure 7.1 shows an example array having N = 10 elements with values in {1,2, . . . ,10}. Initially, the algorithm doesn’t know the loca-tion of the maximum: If we assume that each index is encoded with log 10 ≈ 3.3219 bits, then the initial distribution is uniform. After running the algorithm, the location of the maximum is known, which is represented by a delta function concentrating its

probability mass on number 10. Notice that for discovering logN bits of information we are running an algorithm of time complexity O(N) = 2^O(logN), that is, exponential in the number of bits. Compare this to the arguments for the cost of construction presented in Section 6.3.2, page 68.

a) b) c)

Figure 7.1: An Exhaustive Optimization. (a) A shuffled array with numbers from 1 to 10 is given. Initially, the algorithm does not know where the optimum is, which is represented by a uniform distribution (b) over the elements. After the execution of the algorithm, the solution was found, which is represented by a distribution (c) concentrating its probability mass on the maximum.

IfN is small, sayN = 10, then choosing the largest number is easy, because one can simply revise the whole array and then pick the largest number. However, if N is very large, say N = 1000, then comparing all the numbers becomes a difficult task. How do we go about this problem then? One solution would be to limit ourselves to comparing only a fraction of the array, say M ≪ N elements. This reduces the computational complexity to O(M) time and O(logN) space at the cost of tolerating an error with probability 1−M/N. That is, we can give up certainty for the sake of computational efficiency. Notice that the time-space product is O(MlogN), which is linear in M for fixed N.

To understand the effect of the resulting tradeoff, we again analyze how the know-ledge state is transformed. We assume that the set was shuffled beforehand and that the algorithm inspects the first M outcomes in linear order, choosing the largest number.

We then use the frequency of choosing each number as its probability. This assigns equal probability to each one of theN! possible permutations of the array. The resulting probability distributions are shown in Figure 7.2. Here, we see that inspecting only one element does not change the state of knowledge at all; that increasing M moves the probability mass towards the larger numbers; and that complete certainty is achieved when M = N. Furthermore, notice that we can actually infer the ranking of the numbers by merely looking at the distributions, since larger numbers consistently get more probability mass.

The particular shape of the resulting distributions has some interesting properties.

Letρ denote the relative entropy between the initial and the final distribution, and let C =M−1 denote the number of comparisons carried out by the algorithm, and letV denote the expected maximum. Note thatC= O(MlogN) for fixedN, i.e. it serves as a measure of the computational complexity. If we plotρ versusC (Figure 7.3a), we see

M = 1 M = 2 M = 3 M = 4 M = 5

M = 6 M = 7 M = 8 M = 9 M = 10

Figure 7.2: Distributions after Bounded Optimization. The plots show the distributions over the maximum in{1,2, . . . ,10}obtained after running the bounded optimization algorithm for different values ofM.

a surprising property: the quantities are proportional, having a correlation coefficient¹ ofr = 0.9991. That is, we can useρas a good measure of the computational complexity of the algorithm. We also want to understand how the expected valueV evolves as we increase the computational effort. This is seen by plotting V versus ρ (Figure 7.3b).

This plot shows that certainty has a diminishing marginal value, that is, the gain in the value decreases with more computation. Intuitively, this is because the better the candidate solution, the more effort it takes to find an even better one. Moreover, the shape of the expected utility turns out to be logarithmic, as can be seen by plotting 2^V versus ρ.

Intuitively, if we care about computational costs, then it is not always a good idea to run an exhaustive optimization algorithm, because we can reach a point where the gain in value is too small to justify the extra computational effort. This idea can be captured by changing the evaluation criterion to one that penalizes the expected value by the relative entropy, e.g.

V −αρ,

whereα is a conversion factor. Fixing α defines a tradeoff between the expected value and the relative entropy (Figure 7.4). The plot confirms our intuition: the smaller α, the larger the number of elements we compare, and the more “rational” our choice becomes. A brief simulation also shows that a achieving a perfectly rational choice does not requireα= 0; it is already achieved for α≈0.2131.

This analysis leads to a principled algorithm for bounded optimization. For a fixed α, consider the algorithm that linearly inspects the elements of the array until

1More precisely, thePearson product-moment correlation coefficient is an indicator of the linear dependence between two variables, having values ranging from−1 to 1. A value equal to 1 means that a linear relation perfectly describes the relationship between the two variables.

a) b) c)

ρ

C

U

ρ

2^U

ρ

r= 0.9991 r= 0.9937

Figure 7.3: Performance of the Bounded Optimization. In panel (a), it is apparent that the relative entropyρis proportional to the number of comparisonsCcarried out by the algorithm, and henceρserves as a measure of the computational complexity. Plot (b) shows the expected valueV against the relative entropyρ. The marginal increment ofV diminishes asρincreases.

Furthermore, panel (c) shows that 2^V is linear inρ, meaning thatV is logarithmic in ρ.

V−αρ

ρ

α= 0.5 α= 1.0

α= 2.0

Figure 7.4: Expected Value Penalized by Relative Entropy. Choosing the conversion factorα defines a tradeoff between the expected value and the relative entropy. In the plot, three performance curves are shown, corresponding to the tradeoffs α= ¹₂,1 and 2. Notice how an exponential increase ofαleads to a linear increase in the optimalρ.

the largest number found so far, penalized by αρ, reaches its peak. This algorithm is stochastic, with the property that the probabilities of choosing a number are monotonic:

for all i, j,

p_i> p_j ⇐⇒ v_i > v_j

wherevi is the value of the i-th element and and pi is its probability of being chosen.

This seems to be a more general property of a bounded optimization algorithm. Fur-thermore, notice that because of the diminishing marginal value, it is easy to reach a good performance level (although it is very hard to approach the optimum).

This concludes our example. In the remainder of this chapter, we aim to develop a general framework of bounded rationality and then apply it to autonomous systems.

We are especially interested in providing a solid axiomatic basis for bounded rationality.