Evaluation and Improvement of Laruelle-Widgrén Inverse Banzhaf Approximation

In our paper we focus on the algorithm by Laruelle and Widgrén. It is a relatively simple algorithm that uses the fact that every input (the weight of the player) has a corresponding output (the power of the player) and that there is a correlation between input (weights) and output (power distribution) of the Banzhaf algorithm – increasing or decreasing the input often leads to similar changes in the output.

Using that fact, Laruelle and Widgrén constructed an iterative algorithm. In every step, they update the weights of the players by calculating the Banzhaf index, calculating the ratio of the banzhaf index divided by the target power index per player and then dividing the weight of each player by its corresponding ratio. That way the weights are adjusted according to the error in the Banzhaf index.

The target vector is used as the first set of weights. This makes sense because the power and the weight distribution are roughly correlated. From this starting point it is possible to iterate as many times as desired. A distance threshold can be set so the algorithm will stop when it is close enough, and a maximum number of iterations can be given to make sure the algorithm takes only a limited amount of time.

A pseudocode version of this algorithm is given in Algorithm 1. It takes as input the vector ‘target’ (also called $t$ below) and the numbers ‘maxDistance’ (the distance threshold) and ‘maxIterations’ (the maximum number of iterations). The vectors weight, banzhafIndex and ratio are all vectors of equal size equal to the number of players.

The authors do not give any guarantees about the algorithm. In their paper it is shown to give a good approximation for some cases, but the general case is not analyzed.

The quota $q$ determines when a coalition has enough weight to win. There has been some work on the effect of manipulating the quota by Zuckerman et al. [13]. In particular, they show that the worst case difference in power under a change in $q$ is bounded for a given set of players. This is relevant when we consider what will happen to the Banzhaf power of the initial weight, as it means that small changes in $q$ for a fixed $\omega_{0}$ produce stable changes in its power.

Our intuition is that $q$ determines the average swinging coalition size, where we call a coalition swinging iff it is winning but contains at least one player which can make it losing by leaving the coalition. A good example of this effect can be seen for the weights $\begin{bmatrix}\frac{1}{n}&\frac{1}{n}&\ldots&\frac{1}{n}\end{bmatrix}$. Under these weights the power vector is always the same since all players have equal weight. However the underlying game changes with $q$. When $q\leq\frac{1}{n}$ every player can win on its own, and the average swinging coalition size is $1$ (when there is a coalition of two or more, no single player can make it losing of leaving because the remaining players are sufficient for winning, hence it is not a swinging coalition). When $\frac{1}{n}<q\leq\frac{2}{n}$ every pair of players can win, and the average swinging coalition has size $2$, and so on.

If $q$ determines the average size of the swinging coalitions, then the best value of $q$ should be $0.5$. This is due to the fact that the number of possible coalitions of a given size $s$ out of $n$ behaves as a binomial distribution, with the largest number of possible coalitions occurring for $s=\frac{1}{2}n$. Having more coalitions to choose from is better because it gives a higher granularity in the Banzhaf vectors available, which should lead to a Banzhaf vector that is closer to $t$. Because of the nature of the binomial distribution, we expect $q$ to behave symmetrically.

Another way to analyze the effect of $q$ is to look at its behavior for small numbers of players. In particular, when the number of players is three, we can visualize the Simplex in $2$D. This is done in figure 1, for three different values of $q$. Because we’re looking at the ordered Simplex, we only have to show the part of the regular simplex where the value (in these figures we show both weights and power) of the first player is not smaller than that of the second player, whose value is not smaller than the third player’s. The figures show how different weight vectors (points in the ordered simplex) map to the four available Banzhaf vectors for 3 players (the four different colors), for three values of $q$ (Figures a through c). Only four Banzhaf vectors are attainable in WVGs on three players: $[1,0,0]$ (red, at the top), $[\frac{1}{2},\frac{1}{2},0]$ (blue, on the left), $[\frac{3}{5},\frac{1}{5},\frac{1}{5}]$ (green, directly below red), and $[\frac{1}{3},\frac{1}{3},\frac{1}{3}]$ (yellow, directly below green).

As we can see in the figures, not all Banzhaf vectors are always represented by 2D planes or segments of the Simplex. When $q=0.5$ one Banzhaf vector maps to a line (a green line between the red and the yellow areas), while another (blue) maps to a point. When the first player has more weight than the quota of $0.5$, the others must have less and thus he becomes a dictator. On the other hand, when he has less than $0.5$ the same holds for the other two and no-one can win without a second player. Thus only when the first player has weight exactly equal to $0.5$ can the other two vectors be reached. This is a challenge for any iterative algorithm, since they must potentially converge to a very small segment of the Simplex.

Also, from figure 1 we can see that the size of a segment of the Simplex that maps to a specific Banzhaf vector does not behave linearly for increasing $q$. Starting at $q=\frac{1}{2}$, the segment for $\beta=[\frac{1}{3}\>\frac{1}{3}\>\frac{1}{3}]$ first shrinks to a point towards $q=\frac{2}{3}$, and then grows to be a plane again when $q=\frac{3}{4}$.

The meaning of such a $2$D segment for the algorithm can be explained by looking at the ratio calculation in step six. For any Banzhaf vector and the given target power distribution, the ratio is uniquely defined. In other words, when the algorithm considers weights $\omega$, the update operation is uniquely defined by the Banzhaf vector that $\omega$ maps to. Where $\omega$ maps to is only controlled by parameter $q$.

The particular challenge for the algorithm is that the update step $\text{weight}=\frac{\text{weight}}{\text{ratio}}$ is not always defined. When the Banzhaf power vector contains a $0$ (red or blue in figure 1) the ratio is also $0$, and the algorithm cannot continue. Such Banzhaf vectors appear only at the edges of the Simplex.

The effect of $q$ on the algorithm is thus not easily predicted. On the one hand, the algorithm does not always preserve weights, and therefore is not restricted to exploring just the weight vectors in the Simplex. On the other hand, the size differences between Banzhaf segments and existence of segments that stop the algorithm poses challenges.

The authors of the original algorithm select the target vector $t$ as initial weights $\omega_{0}$ (the weights in the $0$th iteration) under the implicit assumption that this is a close guess to the final power distribution. However, we have seen in the previous section that this can lead to initial weights that produce a powerless player. This results in the algorithm dividing the weights by a zero ratio, and thus stopping after only one iteration. This may lead to poor approximation, and therefore this section attempts to find different guesses for $\omega_{0}$ to avoid this situation.

When considering choices for $\omega_{0}$ we may try the vertices of the ordered regular Simplex. However, all but one of the vertices contain at least one zero. The ‘outer’ vertices of the regular Simplex thus immediately lead to a zero in the Banzhaf vector. For the same reason we should avoid the edges and higher dimensional ‘sides’ of the regular Simplex. This leads us to the intuition that a good starting point is far from the edges.

The vertex of the ordered regular $n$-Simplex without a zero power player has the form $\begin{bmatrix}\frac{1}{n}&\frac{1}{n}&\ldots&\frac{1}{n}\end{bmatrix}$. This point is also the centroid of the regular Simplex. A centroid is a type of center, intuitively defined as the average of all vectors in the body, or alternatively as the center of its mass. The centroid of a general Simplex is computed as the normalized sum of its $n$ vertices ($v_{0}$ through $v_{n-1}$):

This point seems to be a good candidate for $\omega_{0}$, as it is the furthest from all sides. It is also the starting point used by the approximation algorithm of Fatima et al. [7]. However, it actually leads to the same situation as choosing the target vector, only one iteration later. The explanation for this is that when all weights are equal the Banzhaf vector is the same as the weights. Then the computation for $\omega_{1}$, the weights in the first iteration, becomes (for each player):

However, we can still use the notion of centroid applied to the ordered Simplex. This point is also far from all sides, and furthermore appears to be in a region of the Simplex where there are many Banzhaf vectors. We base this intuition on the views of Kurz [9] on the location of Banzhaf vectors in the ordered Simplex. Starting close to many Banzhaf vectors is desirable, because then each iteration is likely to jump to a new Banzhaf vector which in turn results in a slightly different ratio. Changing the ratio often introduces variance in the direction of update which intuitively leads to better convergence.

The interior vertex can also be used in another way: We may manipulate the starting weight vector based on the target vector $t$, so that it is less likely to start with a powerless player. Players are powerless when they only have a very small weight which in the Simplex means that some other players have a very large weight. We can smooth this initial weight distribution by averaging $t$ with the interior vertex, intuitively ‘pulling’ the target $t$ towards the center, away from the zero edges. This initial weight vector $\omega_{0}$ is computed as

Because the relative effect of these alternative starting points on the performance of the algorithm is hard to assess analytically, we evaluate them empirically. We consider three choices of $\omega_{0}$ in our evaluation.

1. 1.

   Target, the starting point used by Laruelle and Widgrén.

2. 2.

   Centroid, the center of mass of the ordered Simplex.

3. 3.

   Offset Target, the starting point halfway between the target and the centroid of the regular Simplex.

Each choice attempts to satisfy different conditions. Starting point $1$ is likely closest to the desired power. Starting point $2$ is in an area that is dense in Banzhaf vectors. Starting point $3$ attempts to combine both aspects.

In this section we present the metrics used to evaluate the effect of various parameter combinations. Since the purpose of the algorithm is to find a Banzhaf vector $\beta_{\text{opt}}$ that is closest to the input target vector $t$ it is natural to consider the distance between $t$ and the algorithm’s output, for some notion of distance. For our evaluation we use the concept of Manhattan or Taxicab distance $d_{1}$, or $||.||_{1}$. We chose this distance norm because it relates to the results in [9] on the lower bound on the distance between $t$ and $\beta_{\text{opt}}$, and because it is cheap to compute. Formally:

The maximum value of $d_{1}$ in the regular Simplex is $2$, for example when comparing $\begin{bmatrix}1&0&\dots&0\end{bmatrix}$ and $\begin{bmatrix}0&1&\dots&0\end{bmatrix}$. In the ordered regular $n$-Simplex this maximum is $2-\frac{2}{n}$, when comparing $\begin{bmatrix}1&0&\dots&0\end{bmatrix}$ and $\begin{bmatrix}\frac{1}{n}&\frac{1}{n}&\dots&\frac{1}{n}\end{bmatrix}$.

In order to illustrate our evaluation metrics, Figure 2 presents an example of the distance between $t$ and a number of related Banzhaf vectors. In the figure, we consider the following Banzhaf vectors:

• •

  $\beta_{\text{opt}}$, an unknown optimal answer.

• •

  $\beta_{\text{best}}$, a best known (closest) algorithm output found in a database of previously returned Banzhaf vectors.

• •

  $\beta_{\text{alg }i}$, the algorithm output for certain parameter settings $i$.

There may be more than one optimal answer, for example when for two players the target $t=\begin{bmatrix}\frac{3}{4}&\frac{1}{4}\end{bmatrix}$ there exist two optimal Banzhaf vectors $\beta_{\text{opt}}=\begin{bmatrix}\frac{1}{2}&\frac{1}{2}\end{bmatrix}$ and $\beta_{\text{opt}}=\begin{bmatrix}1&0\end{bmatrix}$, both at distance $\frac{1}{2}$. Thus there can also be more than one best known Banzhaf vector, for example when both $\beta_{\text{opt}}$ are present in the database. A given algorithm parameter setting always produces the same result since the algorithm is deterministic.

We thus propose two metrics of interest:

1. 1.

   The relative improvement obtained by using a parameter setting $2$ compared to $1$,

   $$\frac{d_{1}(t,\beta_{\text{alg }1})-d_{1}(t,\beta_{\text{alg }2})}{d_{1}(t,\beta_{\text{alg }1})}$$

2. 2.

   The error in the output produced by a run of the algorithm defined as

   $$d_{1}(t,\beta_{\text{alg }i})-d_{1}(t,\beta_{\text{opt}})$$

The relative improvement tells us something about the usefulness of a specific parameter setting. In other words, it tells us how the algorithm should be used to get the best possible results. In figure 2 we can see that the point for $\beta_{\text{alg }2}$ lies inside the black diamond indicating $d_{1}(t,\beta_{\text{alg }1})$. Thus, it is an improvement over $\beta_{\text{alg }1}$. In the computation for improvement we do not compare the points directly, but rather the distance to $t$, or the minimum Manhattan distance between $\beta_{\text{alg }2}$ and a point on the diamond for $\beta_{\text{alg }1}$ in figure 2.

The improvement can be computed exactly since it only uses the known vectors. We note that the improvement may be negative, for example in figure 2 this is the case for $\beta_{\text{alg }3}$ compared to $\beta_{\text{alg }1}$. We consider an improvement to be significant if it exceeds $0.05$.

The error tells us something about the general usefulness of the algorithm. The error is the minimum Manhattan distance between two points on the green and black diamonds in figure 2. Since we do not know $\beta_{\text{opt}}$ the error must be estimated.

An upper bound on the error is $d_{1}(t,\beta_{\text{alg }i})$. This corresponds to the distance between a point on the black diamond and $t$ in figure 2. This upper bound is tight, since it could be that $t=\beta_{\text{opt}}$, in which case $d_{1}(t,\beta_{\text{opt}})=0$.

A lower bound on the error is $d_{1}(t,\beta_{\text{alg }i})-d_{1}(t,\beta_{\text{best}})$. In figure 2 it is the minimum Manhattan distance between any two points on the black and blue diamonds. This lower bound is also tight, since we may have stored the optimal answer in which case $\beta_{\text{best}}=\beta_{\text{opt}}$.

The upper bound $d_{1}(t,\beta_{\text{alg }i})$ is a biased estimate of the actual error, since it is in general not the case that $t=\beta_{\text{opt}}$. This is a consequence of the fact that Banzhaf vectors are discrete. Kurz proves in [9] that there exists a lower bound on the largest $d_{1}(t,\beta_{\text{opt}})$ of $\frac{1}{9}$, and conjectures that this bound is actually $\frac{14}{34}$.

The bias of the lower bound depends on the bias that originates from our method of obtaining Banzhaf vectors. The quality of the lower bound further depends on the percentage of all Banzhaf vectors we have in our database. We generated Banzhaf vectors by running the algorithm on random samples and storing the vector computed in each iteration of the algorithm (step four) until the database remained constant for $250$ samples. For $8$ players this resulted in $1,094,138$ Banzhaf vectors, which compared to the $2,730,164$ weighted voting games that exists for $8$ players [6, 9] means that there exists at least $1$ vector for every $2.5$ games at this size.

The conjectured lower bound of $\frac{14}{34}$ on the largest distance between $t$ and $\beta_{\text{opt}}$ can be used to determine the size of a significant error for the upper bound estimate. We say that the upper bound error of an algorithm (parameter setting) is significant if the average value of the error exceeds $10\%$ of $\frac{14}{34}$, or $\frac{7}{185}$. Further, we say a change in the error is significant if the difference exceeds $1\%$ of the maximum value of $d_{1}$. Then a significant error for the lower bound estimate is at least $1\%$ of the maximum value of $d_{1}$.

For our experiments we need a number of target vectors $t$ to apply the algorithm on. Since a target vector is a vector in the simplex, we produce samples $t$ by drawing a vector uniformly at random from the $n$-dimensional ordered regular Simplex. If function $U(0,1)$ returns a value drawn uniformly at random from the interval $[0,1]$, such a sample is constructed as:

The elements from the vector $\tilde{t}$ are then normalized so that the resulting vector $t$ sums to $1$:

This results in a vector $t$ that is a random vector in the regular Simplex. To obtain a random vector in the ordered regular Simplex, the elements of the vector $t$ are sorted so that they are in descending order.

In order to evaluate empirically what choices of $q$ and $\omega_{0}$ produce the best results, we performed a number of experiments. For our experiments we drew $10,000$ samples from the ordered $8$D Simplex. On each sample we applied the algorithm for all choices of initial weight vector discussed in Section 4.2, and for $q$ ranging from $0.05$ to $0.95$ in steps of $0.05$. Each parameter combination was run for $50$ iterations.

Figures 3 present the relative improvement obtained by running the algorithm with varying values of $q$ compared to running the algorithm with $q=0.5$ for each $\omega_{0}$. We expect $q=0.5$ to be the best setting, and that the effect of $q$ is symmetric. Thus we expect the relative improvement to be negative when $q\neq 0.5$, with equal magnitude on either side.

The figures show that the effect of $q$ on the mean improvement is generally symmetric. However, the algorithm does seem to perform better on values of $q>0.5$, with the best mean performance occurring for $q=0.65$ for $\omega_{0}$ set to the target, and $q=0.6$ for the other choices of $\omega_{0}$. This average improvement on $q>0.5$ is only significant for $\omega_{0}$ set to the target. The asymmetry in the results may be caused by the update rule of the algorithm. In step six, the weight is updated as $\text{weight}=\frac{\text{weight}}{\text{ratio}}$. The ratio is independent of $q$ as it is computed from the normalized Banzhaf vector and the desired power. However the magnitude of the weights is dependent on $q$ since as $q$ becomes smaller an equal change in weights has a bigger relative effect.

Furthermore, choosing $q\neq 0.5$ results in significant improvements for the majority of samples when $q$ is chosen to be within $0.1$ of $0.5$ for all $\omega_{0}$. We expect that this is caused by the reduction in the area of the ordered Simplex that maps to the Banzhaf vector $[1\,0\,\ldots\,0]$. When $q=0.5$ a weight vector maps to $[1\,0\,\ldots\,0]$ whenever the first player has weight of $0.5$ or higher. As $q$ increases this area shrinks because the first player must have a higher weight to surpass $q$. Conversely, when $q$ decreases this area also shrinks because the other players need less weight to surpass $q$ themselves. We suspect this gives the algorithm more room to adjust the weights.

Figure 4 presents the effect of $\omega_{0}$ when $q=0.6$. The y-axis shows the relative lower bound error, computed as the lower bound on the error divided by the initial distance $d_{1}(t,\beta(\omega_{0}))$, and the initial distance $d_{1}(t,\beta(\omega_{0}))$ on the x-axis. This should show if there is a correlation between the error and the initial distance as produced by the choice of $\omega_{0}$.

Table 1 presents the key features of the data in figure 4. The first column shows the method for selecting the initial weight vector for the algorithm. The second column shows the average initial distance to $t$, and therefore the upper bound on the average initial error. The third column presents the worst case distance to $t$ after applying the algorithm, and thus the worst case error. Columns four and five present the average upper and lower bound error, where we note the average upper error is the average distance to $t$ after applying the algorithm.

The figures show how the initial distance is affected by the choice of $\omega_{0}$, with $\omega_{0}$ set to the target having the smallest initial distance and offset having the largest. For $\omega_{0}$ set to either target or offset a higher initial distance generally results in a higher relative error, while for $\omega_{0}$ set to centroid the opposite appears to happen where the higher initial distances are improved more.

Another aspect of $\omega_{0}$ set to the target is that a large number of samples seem to be unimprovable, which is visible as a large number of samples with relative error near $1$. This may be caused by samples starting in a segment with a $0$ power player, which therefore cannot be improved beyond their initial guess.

The consequence of these unimprovable samples is that $\omega_{0}$ set as offset or centroid gives a significant improvement in both the upper and lower bound error compared to $\omega_{0}$ as target. However, the total magnitude of the error is still significant in all cases. The difference between offset and centroid is not significant, but offset does produce the lowest worst case distance to $t$, and it can thus be seen as the most robust. Overall we can conclude that starting close to the target is less important than starting in a position where the algorithm can improve the result.

Because a large portion of samples could not be improved when $\omega_{0}$ is set to the target vector, we want to examine how general this behavior is. For our second experiment we varied the number of iterations from $1$ to $100$ for $q=0.6$ and the three different choices of $\omega_{0}$. We drew $10,000$ samples from the $8$D Simplex and counted how often a sample $t$ ended in a Banzhaf vector with a zero power player for increasing number of iterations. This is a cumulative figure: when the algorithm stops on sample $t$ at $i$ iterations performing $i+1$ iterations will also stop the algorithm. Figure 5(a) contains the results, with the number of iterations set on a log scale. Additionally, figure 5(b) shows the mean relative improvement between iterations for this experiment, with the improvement also set on a log scale.

Figure 5(a) shows that the choice of $\omega_{0}$ only has a significant effect on the operation of the algorithm for the first $20$ iterations. At $5$ iterations the difference between starting at the target and starting in the centroid of the ordered simplex is still $10\%$, but this drops to less than $1\%$ when the number of iterations is more than $25$. We can also see that starting in the centroid of the ordered Simplex actually has the best chance of avoiding a zero power player initially. On the other hand, setting $\omega_{0}$ as target gives a $20\%$ chance to start with a zero power player, which results in an unimprovable first guess.

In general, it is obvious that the number of cases where the algorithm stops due to a $0$ in the Banzhaf vector grows with the number of iterations, going from more than $40\%$ at $5$ iterations to above $80\%$ for $100$ iterations. Further, the effect of an iteration is only significant for the first $4$ iterations. This means that generally the algorithm will not manage to converge to the target value, and it also suggests a possible area of improvement.

As we have seen in figure 5(a), the algorithm 1 quickly encounters the situation where computing the ratio results in a divide by zero from a player with $0$ power in its Banzhaf vector. To continue with the algorithm at this point, we may try to find a different transformation to perform on the weights. The resulting new weights are in effect a second guess, leading to a restart with better initial weights. This procedure can then be repeated as often as we can make better guesses, resulting in the Multiple Start version of the algorithm.

The restart guess should be a transformation on the weights discovered during past iterations to make it meaningful. If the restart guess was not based off earlier results, it would be possible to simply apply the original algorithm to this better guess instead. It is also not useful to restart on a set of weights that has already been tried, since the algorithm is deterministic.

A promising place to start from is the set of weights that produced the best power distribution thus far. We propose to use the Offset Target procedure on this set of best weights to obtain a new set of weights halfway between the centroid of the regular simplex and the best weights, as shown in algorithm 2. Our motivation for this choice is threefold:

• •

  We know from the exploration of the Banzhaf vector locations that the majority is located near the center, and thus approaching our target from the center out gives the best chance of finding a closer vector to jump to.

• •

  In our initial experiments, the Offset Target heuristic provided good final results, with the best worst case error and a robust average case.

• •

  We can reason about its positive effect for some non-improvable samples. For example, consider the case when the first player has all the power because he has a weight $\frac{1}{2}<w_{1}<1-\frac{1}{n}$. Then this operation brings his weight below $\frac{1}{2}$. Because the first player had the most weight, this means that all weights are reduced to below $\frac{1}{2}$ and no player can be a dictator in the transformed sample.

We expect this version of the algorithm to never return a solution that is worse than the standard version for the same number of iterations, since it uses the standard version up until the first restart. Restarting may also provide a bigger benefit when the standard algorithm frequently cannot improve beyond the initial guess, which is for values of $q$ near $0$, $0.5$ or $1$. We know that in the limit all inputs tend to go to a power vector with a zero power player, but if the standard algorithm can perform many iterations, there may not be any room for further improvement by starting somewhere else. Thus we expect this algorithm is likely to produce the biggest improvement early on.

Instead of recovering from a situation where a player has no power, we may try to manipulate the algorithm so that it will not produce weights where a player has no power. Laruelle and Widgrén evaluate the EU for different rules, and some of these rules have valuation functions that impose a minimum coalition size (for example, QM+ requires $10$ out of $15$ countries to vote in favor). One aspect of the minimum coalition size is that it gives power to players that normally would not have any.

To show that this is the case, assume a weight distribution where only $w_{1}>0$. Even though player $1$ has all the power, if we impose minimum coalition sizes of $2$ and up, player 1 must form coalitions with others to win. In this way, the other players get some power. Note that for minimum coalition sizes smaller than $n$ the others still get less power than player $1$, since only he is present in all of these coalitions. More generally, the number of possibly winning coalitions is $2^{n}-1$ without restrictions, or $\sum\limits_{i=m}^{n}\binom{n}{i}-1$ for an imposed minimum coalition size $m$.

As a consequence, while this method can resolve cases where the Banzhaf vector would otherwise contain zeros, it also restricts the number of Banzhaf vectors available. For example, the vector $[\frac{3}{5}\>\frac{1}{5}\>\frac{1}{5}]$ has four winning coalitions $[100],[011],[110],[101]$. But the first coalition has size $1$, so it would not be winning if minimum coalition size were set to $2$.

Therefore, we expect that imposing minimum coalition sizes sometimes produces worse results than the standard algorithm. Furthermore, when the minimum coalition size increases, fewer Banzhaf vectors are available, resulting in larger errors. We can thus expect the ideal minimum coalition size to be relatively small.

Another way to work around the case where a player has no power is to always use a strictly positive update coefficient $r$. We may introduce a scaling factor $s$ in both the numerator and denominator of the calculation, i.e. $r_{i}=\frac{\beta_{i}+s}{\beta_{\text{fair}}+s}$. This ensures that for $\beta_{i}=0$ the coefficient is still a positive real.

The secondary effect of this scaling factor is that the magnitude of adjustment is smaller, which leads to slower convergence. This may on its own also lead to better results, since it reduces the risk of overshooting the target vector. On the other hand, it will take more iterations to get to the desired value. Another risk is that the algorithm no longer manages to jump out of local minima.

Since the scaling factor changes the operation of the algorithm, the effect of this change is somewhat uncertain. We may expect better results when the standard algorithm stops in one iteration due to a zero power player. Its effect in general is more difficult to predict. We may need more iterations to get the same or better results as the standard version, if convergence is indeed slower. In other words, there is a possibility of returning worse results in general.