 In the task allocation domain, we were looking for a mechanism which is paired to efficient anonymous and strategy proof. And in this module, we are going to give a very interesting mechanism which is known as the uniform rule. This was proposed by Sproumore way back in 1991. And here is the mechanism which is very interesting. So, let us without loss of generality assume that the sum of these peaks is less than 1, which means that the sum of the most favorite allocations of this task does not allocate the job completely. So, therefore, some agents have to be overloaded. Now, how do we overload? So, this mechanism starts in the following way. In this figure as we have done earlier, this is the complete task and this is 0th share of the task. So, on the y-axis, you have the share of the task. And these are different players, player 1, 2, 3, 4, 5 in this case. And this red dots essentially a red horizontal lines essentially show that what is their peaks. So, these are the peaks for each of these agents. Now, uniform rule starts with the allocation of 1 for all the agents. So, this is something like a thread or a water level that you have given to all the agents. Of course, this is not feasible because now you have n amount of work where you can only allocate 1 amount of work. So, the water level now keeps on coming down. So, this is the idea or the thread that shows the total allocation of all these tasks is coming down slowly in the uniform rate from top. So, the first time it hits one of these peaks. So, let us say in this case this peak is hit, then that particular agent will get that peak. So, let us say p3 is allocated to agent 3. And for that agent, it has been finalized. For the rest of the agents, it keeps on falling again. So, maybe the next agent to hit is p1 and then that gets p1 amount of allocation. And in each of these stages as it is uniformly coming down, you are keeping a running count of how much of the total task has been allocated. So, that the whenever the sum of these tasks for all the agents equal 1, you stop at that point. So, the idea, I mean, you can get the idea very simply. I mean, it is just coming down the thread or the water level is coming down at an uniform rate and that is why the name uniform rule. Whenever it is hitting any of these peaks, that agent gets that peak. And for all the other agents, it is that uniform level. And that uniform level will stop as long as the sum of the shares of all the agents is exactly equal to 1. Similarly, when you are when the opposite situation is true, that is, some of these pIs is strictly greater than 1. That means, some of the most favorite share of the jobs is more than the total job itself. So, therefore, all the agents needs to be under loaded. So, that is, that is when we will look at the water level, but from the bottom, it is uniformly going upwards. And the moment you hit some of these peaks, you allocate that share to that agent and then move on. For the other agents, the water level or the thread level keeps on increasing. So, fair enough, that is the uniform rule. And it is very easy to explain pictorially rather than writing it. So, even though we are going to do that now. So, whenever you have the exact, the sum of the shares, the peaks is exactly equal to 1, then it is unsurprising. So, you just have to give each of these agents their p. The thing that we have just written, explained in the diagram above, that can be written in a little more formal way. So, you are picking the maximum between these two things. So, one is this, you can think of this is the thread level. So, the sigma mu of p is the final thread level where you are stopping. So, you can take a look at this. So, suppose the thread from top. So, this is the case that we have considered. And the thread stopped at somewhere here. So, by then all these three agents were given their favorite tasks and the rest of the two agents, agent 2 and 5 actually got this share of the task. And that is where all these shares has actually become equal to 1. You can see that this thread level, if you call that as mu of p, that thread level is the maximum of that particular player's peak and this mu p. So, mu p is the final point where the thread finally settled and it did not go down any further. For the other agents who speak was above that mu p, for them their peak was chosen. So, that is one way of writing the same thing. The uniform allocation rule essentially gives the max of these two quantities where mu p is nothing but this one. So, we are solving this max of p1 and mu such that this, the sum of these things become equal to 1. So, this is written in a more formal way. The easier way is to visualize using that figure. Similarly, you can also define the alternative case that is when the sum of these peaks is more than 1, then you are actually increasing from the bottom. Then you can similarly verify that this is going to be the minimum of their peak and that level, that water level where it settled finally. Now, let us try to argue why it is anonymous PE and strategy proof. Indeed, it is, it satisfies all these three properties, that is the theorem by Sproumore. So, the first two things are pretty easy to follow. We know that anonymity is when you alter this agent. So, if you go back to this figure, if we change the names of this agents, their allocation would have also changed. So, the thread level or the water level is not tied to any of the agents identities. So, as long as you have the same set of peaks, the corresponding allocation will get altered and that is the definition of anonymity. So, quite naturally, the mechanism is completely agnostic of the agent names. It is only tied to the corresponding peaks. So, anonymity is obvious. Pareto efficiency, we have already discussed this in the module before that whenever we have a Pareto efficient allocation, it must be the case that when the sum of these peaks is less than 1, the allocation should be overloading each of them and there should not be any situation where someone is overloaded, someone is unloaded, then that will never be Pareto efficient. So, which is true in this case. So, this mechanism actually gives everybody overloaded or at least its peak if the sum of the peaks is less than 1. Similarly, for the other case when the sum of the peaks is more than 1, then it gives at most their peaks. So, therefore, this mechanism is essentially Pareto efficient. Now, let us come to the strategy proofness part which is quite interesting. So, in the first case where the sum of the peaks is exactly equal to 1, there is nothing to prove everybody gets their peak. So, there is no reason to misreport for any of these agents. Now, case 1 is the case where the sum of the peaks is less than 1. So, this uniform rule is essentially over allocating the jobs, certain agents not for all agents. Now, because this is where the thread stopped. So, remember that this is the case where the thread was coming from the top. Let us go back to that example. So, the thread stopped somewhere here. Let us continue with that example. So, now in order to, so this 3 agents, so agent 3, agent 4 and agent 1, they have no reason to misreport their preferences because they have got their favorite share of the job. What can happen for the other 2 players, player 2 and player 5 is that if they could have reduced this allocation closer to their peak. But because this is the, it is picking the maxima of the thread where it stopped and the peak of each of these agents, the only way it can change this allocation is by reporting its peak to be somewhere above that thread level. And that is clearly a suboptimal because at this point it is getting, so because this preference is a single peak, so they always prefer something like this allocation more than an allocation which is even further away from its peak. So, the allocations fall monotonically from their peak. So, they will always dislike this alternative than the current allocation that they are getting. So, therefore, there is no reason and you can argue in a very similar way for the other case where you are increasing the water level or the thread level from bottom in the situation where some of this PI is greater than 1. So, there is no reason for any of these agents to misreport their peaks because the only way they can change the outcome is by reporting their peaks on the other side of that thread which they prefer less. So, that is essentially the proof where we essentially show that this mechanism, this uniform rule mechanism is a strategy proof as well. The converse is also essentially true for any deterministic social choice function that is, so it should be more formally written as a deterministic because we do not know about the randomized mechanisms. Any deterministic social choice function that is strategy proof, paired to efficient and anonymous if and only if it is an uniform rule. So, that is a result due to SPRMO. The proof is even more involved. So, we are not going into it. If you are interested, you can take a look at this reference. This is the original paper by SPRMO, a division problem with single peak preferences.