This chapter assumes that the agents have a qualitative method to value the coalitions. The qualitative method used wassocial-values, as recent work in argumentation suggests that agent systems can be more richly described with the inclusion of these social-values [10,125] as op- posed to just describing systems with goals. Social-values provide reasons why agents may sometimes want to achieve one goal in one situation, and achieve a different (and perhaps con- tradictory) goal in another situation.
However, using a purely qualitative method to value the coalitions raises several issues:
1. What is the best set of coalitions to choose?: When analysing a VAF to find acceptable arguments for coalitions, the agents in the coalitions of arguments that arecoalitionally objectively-stable andcoalitionally subjectively-stablehave no reasonable logical alter- native. But agents in the coalitions of arguments that arecoalitional subjective-unstable have at least one logical alternative, which raises the following further issues:
2. Differentiating between coalitions promoting the same social-value: Some coalitions may achieve the same goal and promote the same value, but not to the same degree. For example, say some agents join together in a coalition to repair a resource that they will mutually benefit from, thereby promoting the social-valueefficiency of resource. Yet there may be a few ways to promote this social-value that will improve the efficiency on different scales. Consideration of the degree of social-value promotion/demotion is left as a future avenue for research.
3. How to offer incentives to choose a coalition: If no acceptable coalitions can be formed using the definitions given in Section3.5, then at least one agent needs to be incentivised to change its value ordering for a coalition to become acceptable to all of its members. But how the agent can be incentivised in this model is unclear. In transferable utility games [83], an agentican be incentivised to join a coalitionCthrough the rest of the members ofCofferingimore proportion of the transferable utility value payoff ofC. This idea of using transferable utility as an incentive to form a coalition can help with the reasoning on what coalitions should be chosen. Yet this transferable utility incentivisation cannot be achieved in the qualitative representation presented in this chapter.
4. How to defined the maximum social welfare: It can be desirable to design an agent system to maximise social welfare, even in the self-interested multi-agent systems con- text. For example, the cooperative game theory solution concept of thecoreis defined for self-interested agents and maximises social welfare [83]. Yet there is no way to define the maximal social welfare in this model because there is no method to compare between coalitions promoting the same social-value and no method to compare the utility differ- ence between one coalition promoting one social-value with another coalition promoting another social-value.
All these identified issues can be solved using a quantitative transferable utility based ap- proach to coalition formation. Quantitative transferable utility approaches: (i) define the best set
of coalitions to choose via cooperative game theorysolution concepts9; (ii) allow all coalitions to be differentiated by the utility value that they are assigned; (iii) allow incentives to be offered to agents to join a coalition via the transferable utility property; and (iv) define the maximum social welfare by the total utility value that all the coalitions achieve.
Therefore in the next chapter, the coalition formation process will be discussed from a quan- titative valuation approach. Chapter 4 and Chapter 5 assume that each agent holds the same valuation for each coalition, while Chapter6will look at situations where valuation disagree- ments between the agents could occur.
9
Distributing Coalition Value
Calculations
This chapter investigates the best way to distribute the coalition value calculations in character- istic function games to the agents of a multi-agent system.
In a characteristic function game, each coalition’s value should be calculated as an agent can potentially join many different coalitions, and so must choose which coalition to join. As the number of coalitions grows exponentially with the number of agents, the burden of requiring every agent to calculate all of the coalition values is high1. Furthermore, the complexity of calculating an individual coalition’s value can vary, and potentially be exponential [106]. Thus, even if each agent only calculates the value of those coalitions that it can be a member of (i.e.
2n
2 ), then this can still result in a significant overlap of calculations, such that this redundancy can converge to 100%, aslimn→∞ 2
n−1
n2(n−1) = 0.
This chapter’sdistributed coalition generation(DCG) algorithm divides the coalition value calculations between the agents of the system, and has the properties of: (i) no communication is required among the agents; (ii) no coalition’s value is calculated more than once; (iii) the coalition value calculations are divided into shares, one for each agent, in a full and approxi- mately equal manner; (iv) agents with equal sized shares have the same number of operations to perform; and (v) each coalition in an agent’s share includes that agent as a member. No other algorithm apart from DCG has all of these properties, as discussed in detail in Section4.3. The motivation of the DCG algorithm was initially outlined in [102], while the underlining theory was presented in [99]. The proof that the DCG algorithm generates all coalitionsonce and only oncewas developed with Paul Dunne, given in AppendixA. In Chapter5, it will be described how the DCG algorithm can be used as input to a distributed algorithm to find an optimal coali- tion structure and a payoff vector in the weak-least core.
The rest of the Chapter is structured as follows: Section4.1 provides the preliminary ma- chinery for a new method to order and distribute the coalitions, while also providing an intro- ductory example. Section4.2details the DCG algorithm. Section4.3 uses an implementation and theoretical results to analyse the properties of the DCG algorithm when compared to the
1
The exact number of coalitions that can form given a population ofnagents is2n−1.
other coalition value calculation algorithms. Section4.4 analyses the runtime performance of the algorithm. Finally Section 4.5discusses how the DCG could be used in general coalition formation.
4.1
Preliminaries and Introductory Example
The DCG algorithm exploits a novel method for representing and ordering coalitions, so that different coalitions can be allocated to each agent, in such a way as to facilitate the construction ofshares(one per agent) that eliminate redundant coalition value calculations.
4.1.1 The New Ordering Method
In this chapter, a coalitionC ⊆ {1,2, ..., n} is represented as an ordered sequence of identi- fiers (IDs) that form acoalition array, where no agent appears more than once in any coalition, and wheres = |C|. Aninteger increment valuebetween two contiguous agentsiandj in a coalition array corresponds to the difference in the agents’ IDs2. For example, if we have a coalition array [3,6,1], then there are two integer increment values between the ID pairs3,6
and6,1. There is an additional increment between the last and the first agent IDs in the array; i.e. the ID pair1,3. The integer increment valuebetween two agents iandj can be decom- posed into abaseline increment(which is assumed to be 1, since agent IDs are unique) and an offset increment, denoted ti = (j−i)−1 modn (i.e. integers modulon). Thus, ifti = 0, the difference between the IDs for agentsiandj corresponds only to the baseline increment; whereas ifti 6= 0, thenti represents an additional offset increment. An increment array(IA) denotedt=ht0, t1, . . . , ts−1itherefore represents the offset increments between the identifiers of the coalition array. For example, given the coalition array[3,6,1], the corresponding IA will beh2,0,1i.
Aninteger partitionofkis a combination of positive integers that add up to exactlyk. The DCG algorithm uses integer partitions to identify the offset increments between consecutive pairs of IDs in the coalition array. The full set of integer partitions is denoted I(n−s); for example, givenn= 6ands= 3,I(n−s) ={{3},{2,1},{1,1,1}}. Increment arrays can be formed from an integer partitionI for coalitions of sizes,onlywhenI ∈ I(n−s)and|I| ≤s, by including additional zero values to satisfy the property:
s−1 X
i=0
ti= (n−s)
For example, whenn= 6ands= 3, the integer partition{2,1}could be used to form various possible increment arrays: h2,1,0i,h2,0,1i, etc. The integer increment values corresponding to the increment arrayh2,1,0iresult from the two coalition arrays[1,4,6]and[2,5,1], as the ID pairs1,4and2,5share(2 + 1), whereas the ID pairs4,6and5,1share(1 + 1). As IAs are
2
As agent IDs are in the range[1..n], IDs modified using an integer increment will result in an ID modulon. The agent IDnwill be returned when the ID 0 is found because0≡n (modn).
L3 L3,h3,0,0i L3,h2,1,0i L3,h2,0,1i L3,h1,1,1i CV1 1,5,6 1,4,6 1,4,5 CV2 2,6,1 2,5,1 2,5,6 CV3 3,1,2 3,6,2 3,6,1 CV4 4,2,3 4,1,3 4,1,2 4,6,2 CV5 5,3,4 5,2,4 5,2,3 5,1,3 CV6 6,4,5 6,3,5 6,3,4
TABLE4.1: Coalition value calculation shares (CV) for alls= 3agent coalitions in ann= 6
agent coalition-game.
shared between coalition arrays, the new ordering method introduced in this paper divides the coalitions into 2-dimensional listsLs,t.
4.1.2 Example
Each increment array t represents the necessary offset increments from one agent ID of the coalition array to the next. For agentito generate a coalitionC assigned to itself usingt, the first element of the coalition array will beitomotivateito compute the coalition’s value. The second agent IDj in the coalition array will be= (i+t0+ 1) modn; and the third agent ID kwill be= ((i+t0+ 1) +t1+ 1) modn. This continues until the coalition’s sizeslimit has been reached.
Table4.1presents a subset of the coalition arrays, grouped by IAs of sizes= 3forn = 6
agents. Each column represents a single list Ls,t for some IA t, whereas the rows present the coalition value calculation shares (CVs) comprising the different coalition arrays with a common first element (CViis agenti’s share). The table represents all coalition arrays necessary for coalitions of sizes= 3. To assign all of the coalitions, multiple IAs are needed; however, every coalition is assigned once and only once. Note that an integer partition may form more than one increment array; for example the two increment arraysh2,1,0iandh2,0,1iare formed from the{2,1}integer partition.
Four different IAs are required for all the coalitions to be allocated in the above example. The IAtx =h2,0,1iis valid as{2,1}is a candidate integer partition ofI(6−3)that satisfies |{2,1}| ≤s= 3. Yet as|{2,1}| 6= 3, additional zeros are needed to fill up the IA to make the IA the required sizes. If agent 1 usedtx, the coalition array would comprise:
={1,(i+tx0+ 1) modn,((i+tx0 + 1) +tx1 + 1) modn}
={1,(1 + 2 + 1) mod 6,((1 + 2 + 1) + 0 + 1) mod 6}
Alternatively if agent 2 usedtx, the coalition array would comprise:
={i,(i+tx0+ 1) modn,((i+tx0+ 1) +tx1 + 1) modn}
={2,(2 + 2 + 1) mod 6,((2 + 2 + 1) + 0 + 1) mod 6}
={2,5,0} ≡ {2,5,6}
In the above example, the ID 0was generated. As0 ≡ n (modn), this is replaced with ID=n= 6in this coalition.
Each unique IA should be used ntimes (once for each agent) unless the IA includes a se- quence that is repeated throughout the IA. In Table4.1,h1,1,1iis the only IA with a repeated sequence, with{1}being repeatedm= 3times. The number of times an IA with a repeating se- quence should be used relates to the size of the repeating sequence and is given byr(introduced in the next subsection). The choice of agents that should use this type of IA will depend on the allocation of other coalitions; the DCG algorithm balances the number of coalitions assigned to each agent’s share so that an agent’s share can never be greater than two coalitions bigger than another agent’ share.
Thus, if any other IA was used other than the ones listed in Table 4.1, it would result in a coalition’s value being calculated more than once. For example, if agent 6 usedty =h1,2,0i, the coalition array[6,2,5]would be generated despite this coalition being generated by agent 2 usingtx =h2,0,1i.
4.1.3 A Distributed Method for Coalition Generation
Theperiod of t, denoted byπ(t)is defined as: Definition 78:Theperiod oft:
min
1≤p≤st=ht0, t1, . . . , tp−1, t0, t1, . . . , tp−1, . . . , t0, t1, . . . , tp−1i
Hence, tis formed bym identical copies of a sequence of lengthπ(t). The period oftis therefore the length of the smallest subsection oftthat is repeated throughoutt. For example, if t = [3,1,3,1,3,1] then the period of t is 2 because the subsection [3,1] is the smallest subsection repeated throughoutt. Additionally if t= [3,1,3,1,3,1], thenm = 3because the subsection[3,1]is repeated 3 times withint.
Definition 79:Calculating an agentag’s coalitionCgiven an IA array t:
GivenC⊆ {1,2, . . . , n}, agentaggeneratesCfromag ifC={ag1, ag2, . . . , ags}and:
agi= ag if i= 1 (ag+φi) modn if (ag+φi) modn6= 0 n if (ag+φi) modn= 0
where: φi = i−2 X k=0 tk+ (i−1)
Additionally,C(ag, t)denotes the subset of{1,2, . . . , n}generated by the IAtfrom agent ag. The proofs in AppendixAdemonstrate that eachtonly needs to be used byr= (n×π(t))/s different agents. If more thanr agents use tto generate a coalition, then repeated coalitions will be generated. For example, if the chosen IA from Table 4.1 is tq = h1,1,1i then r = (n×π(tq))/s= (6×1)/3 = 6/3 = 2agents should usetq, which is true as any other agent using tq would repeat either coalition{1,3,5}or{2,4,6}. Finally, iftx andty generate the same coalition C for two different agents i, j ∈ C (i.e. C(i, tx) = C(j, ty)), then tx and ty are classified as belonging to the sameequivalence class, denoted tx ≈ ty. For example, the IAsC(2,h2,0,1i) =C(6,h1,2,0i) ={2,5,6}belong to the same equivalence class. We write tx ≈ty whentx=htyk, ..., tys−1, ty0, ..., tyk−1ifor some0≤k≤s−1. To gettyfromtx, it can be said thattx isshifted (s−k) steps. AppendixAproves that rather than consideringevery possible IA, it suffices only to consider asinglerepresentative from each equivalence class≈. The DCG algorithm is designed to only consider a single representative of each class, the one that is the smallest lexicographically, named the canonical representative for its equivalence class and denoted[t]≈.