First Report on a Project Studying the Analysis of Coop

          First Report on a Project to Study Cooperation 
        in Games by Means of Modeling in Terms of Formally 
        Non-Cooperative Action in a Repeated Game Context

    A few years ago I gave a talk on the topic of the use of the 
"Prisoner's Dilemma" game, in a context of repetition and evolution of 
strategies, by theoretical biologists who were interested in studying 
the natural evolution of cooperative adaptations. And after giving the 
talk I thought more about the concept of studying a game by studying it 
as a repeated game and through this viewpoint I got an idea of how to 
eliminate all of the "verbal" complications that could become involved 
in the consideration of coalitions and coalition formation.  
    In principle, coalitions, and specifically coalitions as considered 
by Von Neumann and Morgenstern in "Theory of Games and Economic 
Behavior", are things that could be implemented by contracts, like 
contracts in roman law. But of course a contract is quite intrinsically 
a "verbal" thing because indeed it could (or should!) be written down 
in words.  
      On the other hand, if in Nature a form of cooperation has evolved, 
like with a species of insects providing fertilization for a flowering 
species of plants, then the cooperation exists and is maintained, not 
by the enforcement of a verbal contract but presumably by the action    
of "natural selection" affecting the genetics of both species as time 
passes.  
     My idea was that in a repeated game context that the players could 
be given the right to vote for "agencies" or "agents" among themselves. 
Thus at a first step a player, say player A, would have the option to 
accept player B as his agent. And the effect of this would be that the 
coalition (A,B) would be formed (like a committee with B as chairman) 
without any verbal processes occurring between A and B. Furthermore, 
this process adapts to successive steps of coalescence since if another 
step of elections is held then B, as the "agent" representing the 
coalition (A,B), can vote to accept the agency of player C and then C 
will thus become the agent representing the coalition (A,B,C).  
      And in this manner, with generalized "agencies" being electable, 
the level of a "grand coalition" can always be reached (for a game of 
finitely many players), and as a consequence of that the requisites for 
"Pareto efficiency" will be available.  
      With regard to the actual results which have been obtained and 
which we can report on now, they have been calculations of equilibria 
for models and specific games where there were two or three players. 
The models relate to the representation of the coalescence (or 
coalition formation) possibilities in terms of the concept of agencies 
and the models also incorporate some form of "reactivity" by which 
players can react affirmatively when well treated by others (acting as 
agents) and negatively when badly treated by other players. (And of 
course there is no bound, a priori, to the complexity of reaction 
patterns). But it is somewhat plausible that with a "reasonable" level 
of refinement in the modeling of reactive behavior that we can find 
results, in terms of calculated equilibria of behavior, that will 
be plausible in relation to appraising the bargaining/negotiation 
"values" for the game and also compare calculated value vectors for 
it with other calculable value vectors such as the Shapley value or 
the nucleolus. And the interest in these comparisons is a good reason 
for studying games given as "CF games" (which we will discuss further 
below) so that the Shapley value, the classic nucleolus and the 
"Harsanyi nucleolus" can directly be calculated for these games.  
     We have seen that there is much to do further, even on the level 
of games of merely three players, to refine the modeling. We have worked  
with parameters called "epsilons" which enable some smoothness and good  
mathematical solutions for equilibria when they are finite and, as they  
tend towards zero, limiting results that have Pareto efficiency that 
becomes asymptotically perfect as "the epsilons" pass to zero limits.  
(What is less clear at this stage of the research, for three players, 
is that we can actually evaluate the "division of the profits" as the 
payoffs to the players.)  
       In the continuing text below we will go into specific topics and 
also into some details of calculations and of programming developed to 
achieve the calculation results.

   
                           Agencies

       As was mentioned above in the first paragraph, this research was  
inspired by some study of the work of theoretical biologists working  
with models employing the "Prisoner's Dilemma" game. When I arrived at  
the idea of use of "agencies" as the means for the reduction of the  
potentially quite "verbal" general concept of a coalition to a concept  
well suited for studies based on analysis of the players' motivations 
from the non-cooperative viewpoint of separate and independent utility 
measures I realized also that there was a connection with the studies 
on the topic of "the evolution of cooperation" (Axelrod et al).  
       Instead of there being unlimited means by which coalitions might 
actually be formed or form, dissolve, and reform, we have an election 
procedure through which any player may elect to accept any other player 
as his agent. And in the context of studying a repeated game we can 
afford to prescribe  that this election process is such that the agent 
is entirely uncommitted and his election is irrevocable for each 
specific playing of the game. (Of course election choices are expected 
to vary as the game is repeated.)  
      A set of rules can be devised so that there are election stages in  
each of which all of the players remaining independent (not represented 
by another player as agent) have, each of them, the option of electing 
another player as an accepted agent. It is natural for these rules to 
require convergence so that no more than (n-1) stages of election will 
ever be needed for a game of n players.  
       Election rules need to do something to resolve the impasse of a 
situation where A votes to accept B as his agent but B simultaneously 
also votes similarly for A. It is not exactly clear which rule version 
handles these situations in the most preferable fashion, we have worked 
with more than one variant.  
      When we more recently found, in the course of the use of specific 
model games for calculations, that it seemed to be desirable to allow 
elections to be repeated when an election had failed to result in 
the election of any agency power, this finding had the effect of 
suggesting that election rules which had the effect that at most one 
agency could be elected at any stage of the election process would be 
most convenient.  
     Concerning the general concept of transforming a cooperative game 
into a form where all cooperation must be realized by means of the 
election of agencies, we can remark that this is analogous to thinking 
of committees as being such that all effective actions of a committee 
must take the form of an action by the "chairperson" of the committee.  
    If one begins with a quite general CF game and then if one 
introduces a game formally requiring that all coalition benefits must 
be attained through the means of the action of agents who have the 
authority to represent all the members of the coalition then the 
"agencies game" resulting from this still has the same validly 
derivable characteristic function as the original game. In essence 
the coalitions simply have the same potentialities as before, but in 
a formal sense, for these potentialities to be exploited, the members 
of a coalition would need TO CONSPIRE on a practical procedure for 
electing agents successively and finally taking the effective action of 
the coalition as an action of the agent finally elected to represent all 
of the members of that coalition.  
      Remark: The agencies concept inspired the origins of this research  
project on which we are reporting. And earlier we considered various  
alternative specific schemes of rules for the election of agents and  
agencies. Some earlier texts which describe some of these alternative  
ideas are available on the author's "web page". In particular the  
text of the file "agentt7c.c" gives a good picture of these ideas  
with alternative varieties of election rules being considered.

          The Currently Applied Election Rules for Agencies

     It was initially used just for the purpose of simplifying the      
format of model games and simplifying the calculations needed to      
find the corresponding equilibria (for the game of the realization      
of "coalescence" (and coalition benefits) through the election of 
agencies). But in the process we found that a simplifying format of 
election rules seems to be adequate and convenient. If in a stage of 
elections more than one of the players has voted to give his acceptance 
to another player to become his agent (and as if with "power of 
attorney") then a random process, or "chance move", determines only 
one of those votes as effective, and one of the players has elected one 
of the other players to be agent for him.  
    In our latest modeling for 3-person games we introduced the concept 
of repeating an election if no player had voted to give acceptance to 
anyone as his agent, but this repeated election opportunity was to be 
given only with probability of (1-e4) (one minus epsilonsub4). Then we 
found that we got good results mathematically by considering the 
limiting results as e4 (epsilonsub4) tended to the limit of zero.  
     In general, if there are n players of a game, with this procedure, 
it would take n-1 steps of effective election to achieve the final 
election of an agency for the "grand coalition" (which is the coalition 
including all of the players of the game). And in general, for the 
realization of "Pareto Efficiency", it is needful that the grand 
coalition level is attained.

                            CF Games

   We want to introduce a concept or terminology applying to games 
that are described by a "characteristic function" of the type developed  
by Von Neumann and Morgenstern. There has been a tendency in the many  
publications on game theory to describe a sample game simply by  
specifying its characteristic function. We wish to call such a game,  
for which an underlying "normal form game" or "extensive form game" has  
not been specified, a "CF game". And an important consideration comes  
in here: The characteristic function cannot be considered as fully  
enough descriptive of a game so that an "evaluation concept" (or a  
concept of determining a "value" for the game) that depends entirely on  
the information given by that function would be well based. (This is a  
phenomenon that appears initially in the context of 2-person 
cooperative games as studied by Nash.)  
      And of course both the Shapley value and the nucleolus (imputation 
or value vector) are defined in relation to a characteristic function 
that is presumed given.  
     A "corrected" characteristic function, consistent with Nash's 
theory for 2-person cases was introduced by Harsanyi around 1959 and it 
was further studied by Selten in 1964. And either the Shapley Value or 
the nucleolus can be alternatively calculated from this sort of a 
"modified" or corrected characteristic function.   
       But there is also a paradox that appears with typical examples: 
IF a game has been DEFINED (for purposes of study, perhaps as an 
example) by specifying a characteristic function to describe it THEN the 
characteristic function is correct! So we feel that this is a useful 
and convenient category of example games and wish to have a language 
that allows for its convenient use.  
      Thus we can seek to find, by various means, an "evaluation" of a 
"CF game" described by the numbers of a characteristic function of the 
original type of Von Neumann and Morgenstern). And we can obtain also, 
for a CF game, the modified characteristic of Harsanyi's type. (This 
process of going to the Harsanyi "modified characteristic function" can 
be described as applying the "Harsanyi transform" to the original 
characteristic function.)

                   Pro-Cooperative Games

   There seems to be the possibility that theory for cooperative games,  
of the sort that could prescribe evaluation numbers, like the Shapley  
value or the nucleolus, may work better for games which tend to 
strongly reward cooperation of the players than for those which could 
be regarded as tending more towards favoring non-cooperative behavior 
of the players. This remark is unfortunately both vague and rather 
"verbal".  
      A game of the sort that most simply favors cooperation is a 
game which approximates to a maximally simple game of bargaining. If 
agreement of all players in a three-person game is necessary for them   
to receive the main payoff total and coalitions of merely two of the 
players could get only comparatively quite small amounts then the game 
intrinsically favors the cooperation needed for the realization of the 
benefits of the "grand coalition".  
    (We have used games of this sort as a start for examples for 
explicit calculations in our project of study.)  
     A contrasting type of game is the example game presented by Alvin 
Roth in 1980. His illustrative game led to much discussion and 
arguments and counter-arguments. But Harsanyi, whose own theory was 
considered by Roth not to give an acceptable evaluation for the example, 
himself accepted the critical implications of the example. The thing 
that can be noted about Roth's illustrative game is that the grand 
coalition is totally ineffectual (as it were) and that all of the 
possible payoff is realizable by a coalition of only two of the 
players. (The context is a little complicated by the presentation of   
the game in an NTU form and the need for the value vector concepts to 
proceed via reductions to TU form.) (Here TU and NTU are standard 
terms for transferable or non-transferable utility.)  
       So it seems plausible that Roth's example game can be classed,  
comparatively, as a game not of "pro-cooperative" type. And what we  
are thinking is that the analysis of the process itself of formation of  
coalitions, via non-cooperative underlying motivations, can naturally  
lead to different results for games which tend to favor or disfavor the  
dependence of the players on the achievement of cooperation at the 
level of the grand coalition. (We don't know, at this time, what should 
be a precise definition of "pro-cooperative game" but we feel that it is 
likely that an analysis of negotiation and bargaining, as processes on 
the roadway towards the realization of cooperation, could lead to unique 
solutions and plausible payoff outcomes for certain types of games while 
for other types, perhaps like Roth's example, there could be non-
uniqueness or other deficiencies.)  
     Cooperation is not always intrinsically favored, in nature, or in 
human affairs. Sporting events would become absurd if Sumo wrestlers 
were to spend ALL of their time in polite ceremonies and respectful 
bows. And Nature allows the evolution of parasitism and predation as 
well as the evolution of symbiotic relationships.

           A Consistent Value for Games of Three Players

    In connection with this project I was thinking about how games might 
be most practically described in the process of preparing to study them  
in terms of modeling the processes of "bargaining" and/or "negotiation"  
and "coalescence". And it became clear that the modeling would be much  
simplified if a characteristic function description of the game could 
be used. However I also knew that the procedure of definition of the 
VN&M characteristic function (as defined in "Theory of Games and 
Economic Behavior") could not be viewed as entirely "correct" because 
of its failure to properly analyze the "threat" potentials of the 
various parties in the  game.  
    So the question arose of whether or not the "modified" 
characteristic function defined by Harsanyi (1959, 1962) could be used 
instead and this issue was stimulated by conversations with Shapley at 
Stony Brook 2001 from which I learned that it was viewed as quite 
appropriate to apply the Shapley value calculation with any given 
characteristic function and particularly that of Harsanyi.  
      It can be remarked that this use of the "HCF" (or Harsanyi 
characteristic function) with the Shapley value formula or with 
Harsanyi's procedure in 1959 and 1962, for a general 2-person game 
of TU type (transferable utility), yields the result of Nash in "Two-
Person Cooperative Games" for such a 2-person game.  
     And further study of the possibility of using the HCF to describe 
a game led to a surprise for me when I realized that the nature of the 
reduction of information in moving to that description has the effect, 
since the characteristic function is of such a form that it describes 
effectively a "constant-sum" game, that for three player games a natural 
value concept is definable without making any use of an axiom of linear 
additivity of games. In effect, the Shapley value for the HCF-described 
game emerges as appropriate without the use of a linearity/additivity 
hypothesis.  
       And this is confirmed by the circumstance that for constant-sum 
games of three players the nucleolus and the Shapley value coincide (as 
vectors of three payoffs assigned to the players or as "imputations" in 
the language of VN&M). So the nucleolus, which is not dependent on the 
linear additivity axiom, confirms the value concept that is derivable 
for a game of three players described by an HCF version of 
characteristic function.  
       So these considerations suggest also the idea of "the Harsanyi 
nucleolus" which is definable as the result obtained by first finding 
the HCF (or Harsanyi characteristic function) of a game (which might 
have been originally given as a CF game) and then calculating the 
nucleolus as usual except with the HCF used as the characteristic 
function for the calculation.  
       This results, for games of three players, simply in the Shapley 
value (if we start with a CF game), but for games of 4 or more it is 
something else and a few examples suggested to me that for 4-player 
games it might tend to assign more payoff to apparently favored players 
that the SV does. So the "Harsanyi nucleolus" looks like an alternative 
value concept, for games of 4 or more players, that perhaps should be 
included in studies that compare alternative ideas for values and 
arbitration schemes.

   
                          Other Workers

          The areas of (1): analysis of cooperative games via means of 
non-cooperative theory, (2): value theory, for games, in general, and  
(3): the study of games by means of direct experimentation are relating  
areas that are attracting interest in recent times. We can mention  
representative names of persons doing research in these areas. Armando  
Gomes has studied a model in which cooperation is achieved through 
steps that are taken by the players on a non-cooperative basis. At one 
stage of his studies the result for 3-person games was sometimes the 
nucleolus and sometimes the Shapley value, and thus it was a quite 
suggestive result.  
    And Gianfranco Gambarelli has been studying alternative 
possibilities in the area of "value formulae", where it is good to 
remember that any accepted value concept can be the basis for an 
"arbitration scheme". Gambarelli has been interested in the connections 
with voting power issues similar to those which inspired the invention 
of the Banzhaf index.  
      And Reinhard Selten in recent times has been a leader in the    
direct experimental study of games and how they are actually played    
if experiments are done.  
      Here I can remark that, while my research project does not involve  
experiments with human players at all, it is however as if experiments  
are being carried out on the behavior of robotic players. And the 
nature of the calculations is that one does not know, a priori, after 
designing a model of robotically reactive players, what to expect from 
the results of calculations based on the model. So the process can be 
analogous to experimentation rather than to simply trying to design a 
(somehow "proper") arbitration scheme without regard to the natural 
patterns of behavior of players (possibly human, possibly corporate)   
in a naturally arising game context.

                            References

     The paper in final form will have references to various relevant 
papers "in the literature". These are not included in this preliminary 
text. So that will be the Bibliography for this paper.

                            Appendices

     We include below, as texts in format, some files for programs that 
run under MATHEMATICA to obtain solutions for model games. And also 
there are the pages that describe calculation results for specific 
"cases" in terms of the specific model most recently studied. 
Corresponding to these pages there will also be transparencies that   
can be displayed at the Princeton seminar.  
     And it can be remarked that the paper will need to explain in detail 
about the structure of a model of reactive players whereas this issue 
can be approached to some extent by talk or blackboard in a seminar.  
  

###################################################################################

{Files of programming for calcs.}

{First part is of MATHEMATICA file "execpac.12v.k.s03".}

/////////////////////////////////////////////////////////////////////////////

rr[j_, k_, l_, p_, q_] := rr12[j, k, l, p, q]

rr12[f_, sx_, a_, m_Integer, n_Integer] := Module[{na, w, zx},

If[n < 1, Return[no$$iterations$$error]]; na = 0; zx = rat[sx, m];

Label[o1]; If[na == n, Goto[o2]]; zx = r12f[f, zx, a, m]; na = na + 1;

Goto[o1]; Label[o2]; Return[zx]; ]

rat[x_, k_Integer] := Rationalize[x, 1/10^(k + 2)]

r12f[f_, sx_, a_, n_Integer] := r12fa[f, rat[sx, n], a, n]

r12fa[f_, sx_, a_, n_Integer] := (AccuracyGoal -> n; PrecisionGoal -> n;

WorkingPrecision -> n + 7; Module[{u, s, zx, o, nu, du, x1a, x2a, x3a,

x4a, x5a, x6a, x7a, x8a, x9a, x10a, x11a, x12a,

fx1, fx2, fx3, fx4, fx5, fx6, fx7, fx8, fx9, fx10, fx11, fx12, fe, w},

{x1a, x2a, x3a, x4a, x5a, x6a, x7a, x8a, x9a, x10a, x11a, x12a} = sx;

s = {x1 -> x1a, x2 -> x2a, x3 -> x3a, x4 -> x4a, x5 -> x5a, x6 -> x6a,

x7 -> x7a, x8 -> x8a, x9 -> x9a, x10 -> x10a, x11 -> x11a, x12 -> x12a};

{fx1, fx2, fx3, fx4, fx5, fx6, fx7, fx8, fx9, fx10, fx11, fx12, fe} =

N[{D[f, x1], D[f, x2], D[f, x3], D[f, x4],

D[f, x5], D[f, x6], D[f, x7], D[f, x8], D[f, x9], D[f, x10],

D[f, x11], D[f, x12], f} /. s,

n]; w = {fx1, fx2, fx3, fx4, fx5, fx6, fx7, fx8, fx9, fx10, fx11,

fx12, fe}; w = Rationalize[w, 1/10^(n + 2)];

{fx1, fx2, fx3, fx4, fx5, fx6, fx7, fx8, fx9, fx10, fx11, fx12, fe} = w;

nu = -(a*fe); du = fx1^2 + fx2^2 + fx3^2 +

fx4^2 + fx5^2 + fx6^2 + fx7^2 + fx8^2 + fx9^2 + fx10^2 + fx11^2 +

fx12^2; u = nu/du;

zx = N[sx + u*{fx1, fx2, fx3, fx4, fx5, fx6, fx7, fx8, fx9, fx10,

fx11, fx12}, n]; Return[zx]; Null; ])

rrs[z1_,z2_,z3_] := rrb[f,z1,9/5,z2,z3]

rra[v1_, v2_, v3_, v4_] := rrb[v1,v2,9/5,v3,v4]

rrb[f_, sx_, a_, m_Integer, n_Integer] := Module[{na, w, zx},

If[n < 1, Return[no$$iterations$$error]]; na = 0; zx = rat[sx, m];

Label[o1]; If[na == n, Goto[o2]]; zx = rfb[f, zx, a, m]; na = na + 1;

Goto[o1]; Label[o2]; Return[zx]; ]

rfb[f_, sx_, a_, n_Integer] := rf1b[f, rat[sx, n], a, n]

rf1b[f_, sx_, a_, n_Integer] := (AccuracyGoal -> n; PrecisionGoal -> n;

WorkingPrecision -> n + 7; Module[{u, s, zx, du, b, fx1, fx2, fx3, fx4,

fx5, fx6, fx7, fx8, fx9, fx10, fx11, fx12, fe, fe2, w, st13},

b = a; st13 = N[sbx[{D[f, x1], D[f, x2], D[f, x3], D[f, x4], D[f, x5],

D[f, x6], D[f, x7], D[f, x8], D[f, x9], D[f, x10], D[f, x11],

D[f, x12], f}, sx], n]; st13 = Rationalize[st13, 1/10^(n + 2)];

{fx1, fx2, fx3, fx4, fx5, fx6, fx7, fx8, fx9, fx10, fx11, fx12, fe} =

st13; du = fx1^2 + fx2^2 + fx3^2 + fx4^2 + fx5^2 + fx6^2 + fx7^2 +

fx8^2 + fx9^2 + fx10^2 + fx11^2 + fx12^2; u = -(fe/du); Goto[o2];

Label[o1]; b = (2*b)/3; Label[o2];

zx = N[sx + b*u*{fx1, fx2, fx3, fx4, fx5, fx6, fx7, fx8, fx9, fx10,

fx11, fx12}, n]; fe2 = N[sbx[f, zx], n]; If[fe2 < fe, Goto[o3]];

If[b < 6^(-n), Return[gonetoosmall]]; Goto[o1]; Label[o3]; Return[zx];

Null; ])

sbx[phi_, sxa_] := Module[{xaa, r}, xaa = sb[sxa]; r = phi /. xaa; Return[r];

Null; ]

sb[wq_] := s12b[wq]

s12b[w_] := Module[{j1, j2, j3, a, j4, j5, j6, j7, j8, j9, j10, j11, j12},

{j1, j2, j3, j4, j5, j6, j7, j8, j9, j10, j11, j12} = w;

a = {x1 -> j1, x2 -> j2, x3 -> j3, x4 -> j4, x5 -> j5, x6 -> j6,

x7 -> j7, x8 -> j8, x9 -> j9, x10 -> j10, x11 -> j11, x12 -> j12};

Return[a]; ]

FRTB[w1_, w2_, w3_] := Module[{zx, o}, o = FRTA[w1, w2, w3]; zx = xx12 /. o;

Return[zx]; ]

FRTA[ll_, sx_, n_Integer] := Module[{rx, o, x1a, x2a, x3a, x4a, x5a, x6a,

x7a, x8a, x9a, x10a, x11a, x12a},

rx = Rationalize[sx, 1/10^(n + 2)]; {x1a, x2a, x3a, x4a, x5a, x6a, x7a,

x8a, x9a, x10a, x11a, x12a} = rx;

o = FindRoot[ll == zz12, {x1, x1a}, {x2, x2a}, {x3, x3a}, {x4, x4a},

{x5, x5a}, {x6, x6a}, {x7, x7a}, {x8, x8a}, {x9, x9a}, {x10, x10a},

{x11, x11a}, {x12, x12a}, {AccuracyGoal -> n, WorkingPrecision -> n + 7}];

o = N[o, n]; Return[o]; ]

zz12 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}

xx12 = {x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12}

FRT[w1_, w2_, w3_] := Module[{za, zb, zc}, za = FRTA[w1, w2, w3];

zb = FRTB[w1, w2, w3]; zc = {zb, za}; Return[zc]; ]

SFRB[w1_, w2_, w3_, v_] := Module[{zx, o}, o = SFRA[w1, w2, w3, v];

zx = xx12 /. o; Return[zx]; ]

SFRA[ll_, sx_, n_Integer, kk_Integer] :=

Module[{rx, o, k, x1a, x2a, x3a, x4a, x5a, x6a, x7a, x8a, x9a, x10a,

x11a, x12a}, k = kk/(1 + kk);

rx = Rationalize[sx, 1/10^(n + 2)]; {x1a, x2a, x3a, x4a, x5a, x6a, x7a,

x8a, x9a, x10a, x11a, x12a} = rx;

o = FindRoot[ll == zz12, {x1, k*x1a, x1a/k}, {x2, k*x2a, x2a/k},

{x3, k*x3a, x3a/k}, {x4, k*x4a, x4a/k}, {x5, k*x5a, x5a/k},

{x6, k*x6a, x6a/k}, {x7, k*x7a, x7a/k}, {x8, k*x8a, x8a/k},

{x9, k*x9a, x9a/k}, {x10, k*x10a, x10a/k}, {x11, k*x11a, x11a/k},

{x12, k*x12a, x12a/k}, {AccuracyGoal -> n, WorkingPrecision -> n + 7}];

o = N[o, n]; Return[o]; Null; ]

SFR[w1_, w2_, w3_, v_] := Module[{za, zb, zc}, za = SFRA[w1, w2, w3, v];

zb = SFRB[w1, w2, w3, v]; zc = {zb, za}; Return[zc]; ]

fsb[z_] := sbx[f, z]

ffsb[v_] := sbx[ff, v]

ff0 = s12g

////////////////////////////////////////////////////////////////////////

{Remark: The vector ensemble of 12 quantities appearing just below represents

the 12 equations for the equilibrium, with each expression set equal to zero, and

these quantities are derived from the three payoff functions as differentiated by

various of the strategic variables, etc. The actual payoff functions, much simpler,

enter into the vector of three components given as pay3 below (in terms of the

rather unilluminating "anonymous" xsubi type names of the strategic variables.}

////////////////////////////////////////////////////////////////////////

s12g = {x7/E^(x1/e3) - x8/E^(x2/e3), x10/E^(x4/e3) - x9/E^(x3/e3),

x11/E^(x5/e3) - x12/E^(x6/e3),

((-12*x11)/(1 + (1 - x1 - x3 - x6)^4/e1^4) -

(48*x11*(1 - x1 - x3 - x6)^3*(-1 + x1 + x6))/

(e1^4*(1 + (1 - x1 - x3 - x6)^4/e1^4)^2) -

6*x12*(2/(1 + (1 - x1 - x3 - x5)^4/e1^4) +

(4*(1 - x1 - x3 - x5)^3*(b1 + 2*(-1 + x1 + x6)))/

(e1^4*(1 + (1 - x1 - x3 - x5)^4/e1^4)^2)) -

(12*x7)/(1 + (1 - x2 - x4 - x6)^4/e1^4) -

(6*(-b3 + (b3 + 2*(-1 + x1 + x6))/(1 + (1 - x2 - x4 - x6)^4/e1^4))*

x7)/e3 - (12*x8)/(1 + (1 - x1 - x4 - x6)^4/e1^4) -

(48*(1 - x1 - x4 - x6)^3*(-1 + x1 + x6)*x8)/

(e1^4*(1 + (1 - x1 - x4 - x6)^4/e1^4)^2))/

(12*(1 + x10 + x11 + x12 + x7 + x8 + x9)) -

(x7*(-6*x10*(-b1 + (b1 - 2*x4)/(1 + (1 - x2 - x3 - x5)^4/e1^4)) -

(12*x11*(-1 + x1 + x6))/(1 + (1 - x1 - x3 - x6)^4/e1^4) -

6*x12*(-b1 + (b1 + 2*(-1 + x1 + x6))/(1 + (1 - x1 - x3 - x5)^4/

e1^4)) - 6*(-b3 + (b3 + 2*(-1 + x1 + x6))/

(1 + (1 - x2 - x4 - x6)^4/e1^4))*x7 - (12*(-1 + x1 + x6)*x8)/

(1 + (1 - x1 - x4 - x6)^4/e1^4) -

6*(-b3 + (b3 - 2*x3)/(1 + (1 - x2 - x4 - x5)^4/e1^4))*x9))/

(12*e3*(1 + x10 + x11 + x12 + x7 + x8 + x9)^2),

-(x8*(-6*x10*(-b1 + (b1 + 2*(-1 + x2 + x4))/(1 + (1 - x2 - x3 - x5)^4/e1^

4)) - 6*x11*(-b2 + (b2 - 2*x5)/(1 + (1 - x1 - x3 - x6)^4/e1^

4)) - 6*x12*(-b1 + (b1 - 2*x6)/(1 + (1 - x1 - x3 - x5)^4/e1^

4)) - (12*(-1 + x2 + x4)*x7)/(1 + (1 - x2 - x4 - x6)^4/

e1^4) - 6*(-b2 + (b2 + 2*(-1 + x2 + x4))/

(1 + (1 - x1 - x4 - x6)^4/e1^4))*x8 - (12*(-1 + x2 + x4)*x9)/

(1 + (1 - x2 - x4 - x5)^4/e1^4)))/

(12*e3*(1 + x10 + x11 + x12 + x7 + x8 + x9)^2) +

(-6*x10*(2/(1 + (1 - x2 - x3 - x5)^4/e1^4) +

(4*(b1 + 2*(-1 + x2 + x4))*(1 - x2 - x3 - x5)^3)/

(e1^4*(1 + (1 - x2 - x3 - x5)^4/e1^4)^2)) -

(12*x7)/(1 + (1 - x2 - x4 - x6)^4/e1^4) -

(48*(-1 + x2 + x4)*(1 - x2 - x4 - x6)^3*x7)/

(e1^4*(1 + (1 - x2 - x4 - x6)^4/e1^4)^2) -

(6*(-b2 + (b2 + 2*(-1 + x2 + x4))/(1 + (1 - x1 - x4 - x6)^4/e1^4))*

x8)/e3 - (12*x8)/(1 + (1 - x1 - x4 - x6)^4/e1^4) -

(12*x9)/(1 + (1 - x2 - x4 - x5)^4/e1^4) -

(48*(-1 + x2 + x4)*(1 - x2 - x4 - x5)^3*x9)/

(e1^4*(1 + (1 - x2 - x4 - x5)^4/e1^4)^2))/

(12*(1 + x10 + x11 + x12 + x7 + x8 + x9)),

-(x9*((-12*x12*(-1 + x3 + x5))/(1 + (1 - x1 - x3 - x5)^4/e1^4) -

(12*x10*(-1 + x3 + x5))/(1 + (1 - x2 - x3 - x5)^4/e1^4) -

6*x11*(-b2 + (b2 + 2*(-1 + x3 + x5))/(1 + (1 - x1 - x3 - x6)^4/e1^

4)) - 6*(-b3 + (b3 - 2*x1)/(1 + (1 - x2 - x4 - x6)^4/e1^4))*

x7 - 6*(-b2 + (b2 - 2*x2)/(1 + (1 - x1 - x4 - x6)^4/e1^4))*x8 -

6*(-b3 + (b3 + 2*(-1 + x3 + x5))/(1 + (1 - x2 - x4 - x5)^4/e1^4))*

x9))/(12*e3*(1 + x10 + x11 + x12 + x7 + x8 + x9)^2) +

((-12*x12)/(1 + (1 - x1 - x3 - x5)^4/e1^4) -

(12*x10)/(1 + (1 - x2 - x3 - x5)^4/e1^4) -

(48*x12*(1 - x1 - x3 - x5)^3*(-1 + x3 + x5))/

(e1^4*(1 + (1 - x1 - x3 - x5)^4/e1^4)^2) -

(48*x10*(1 - x2 - x3 - x5)^3*(-1 + x3 + x5))/

(e1^4*(1 + (1 - x2 - x3 - x5)^4/e1^4)^2) -

6*x11*(2/(1 + (1 - x1 - x3 - x6)^4/e1^4) +

(4*(b2 + 2*(-1 + x3 + x5))*(1 - x1 - x3 - x6)^3)/

(e1^4*(1 + (1 - x1 - x3 - x6)^4/e1^4)^2)) -

(12*x9)/(1 + (1 - x2 - x4 - x5)^4/e1^4) -

(6*(-b3 + (b3 + 2*(-1 + x3 + x5))/(1 + (1 - x2 - x4 - x5)^4/e1^4))*

x9)/e3)/(12*(1 + x10 + x11 + x12 + x7 + x8 + x9)),

-(x10*(-6*x10*(-b1 + (b1 + 2*(-1 + x2 + x4))/(1 + (1 - x2 - x3 - x5)^

4/e1^4)) - 6*x11*(-b2 + (b2 - 2*x5)/(1 + (1 - x1 - x3 - x6)^

4/e1^4)) - 6*x12*(-b1 + (b1 - 2*x6)/(1 + (1 - x1 - x3 - x5)^

4/e1^4)) - (12*(-1 + x2 + x4)*x7)/(1 + (1 - x2 - x4 - x6)^4/

e1^4) - 6*(-b2 + (b2 + 2*(-1 + x2 + x4))/

(1 + (1 - x1 - x4 - x6)^4/e1^4))*x8 - (12*(-1 + x2 + x4)*x9)/

(1 + (1 - x2 - x4 - x5)^4/e1^4)))/

(12*e3*(1 + x10 + x11 + x12 + x7 + x8 + x9)^2) +

((-6*x10*(-b1 + (b1 + 2*(-1 + x2 + x4))/(1 + (1 - x2 - x3 - x5)^4/

e1^4)))/e3 - (12*x10)/(1 + (1 - x2 - x3 - x5)^4/e1^4) -

(12*x7)/(1 + (1 - x2 - x4 - x6)^4/e1^4) -

(48*(-1 + x2 + x4)*(1 - x2 - x4 - x6)^3*x7)/

(e1^4*(1 + (1 - x2 - x4 - x6)^4/e1^4)^2) -

6*(2/(1 + (1 - x1 - x4 - x6)^4/e1^4) + (4*(b2 + 2*(-1 + x2 + x4))*

(1 - x1 - x4 - x6)^3)/(e1^4*(1 + (1 - x1 - x4 - x6)^4/e1^4)^2))*

x8 - (12*x9)/(1 + (1 - x2 - x4 - x5)^4/e1^4) -

(48*(-1 + x2 + x4)*(1 - x2 - x4 - x5)^3*x9)/

(e1^4*(1 + (1 - x2 - x4 - x5)^4/e1^4)^2))/

(12*(1 + x10 + x11 + x12 + x7 + x8 + x9)),

-(x11*((-12*x12*(-1 + x3 + x5))/(1 + (1 - x1 - x3 - x5)^4/e1^4) -

(12*x10*(-1 + x3 + x5))/(1 + (1 - x2 - x3 - x5)^4/e1^4) -

6*x11*(-b2 + (b2 + 2*(-1 + x3 + x5))/(1 + (1 - x1 - x3 - x6)^4/e1^

4)) - 6*(-b3 + (b3 - 2*x1)/(1 + (1 - x2 - x4 - x6)^4/e1^4))*

x7 - 6*(-b2 + (b2 - 2*x2)/(1 + (1 - x1 - x4 - x6)^4/e1^4))*x8 -

6*(-b3 + (b3 + 2*(-1 + x3 + x5))/(1 + (1 - x2 - x4 - x5)^4/e1^4))*

x9))/(12*e3*(1 + x10 + x11 + x12 + x7 + x8 + x9)^2) +

((-12*x12)/(1 + (1 - x1 - x3 - x5)^4/e1^4) -

(12*x10)/(1 + (1 - x2 - x3 - x5)^4/e1^4) -

(48*x12*(1 - x1 - x3 - x5)^3*(-1 + x3 + x5))/

(e1^4*(1 + (1 - x1 - x3 - x5)^4/e1^4)^2) -

(48*x10*(1 - x2 - x3 - x5)^3*(-1 + x3 + x5))/

(e1^4*(1 + (1 - x2 - x3 - x5)^4/e1^4)^2) -

(6*x11*(-b2 + (b2 + 2*(-1 + x3 + x5))/(1 + (1 - x1 - x3 - x6)^4/

e1^4)))/e3 - (12*x11)/(1 + (1 - x1 - x3 - x6)^4/e1^4) -

6*(2/(1 + (1 - x2 - x4 - x5)^4/e1^4) + (4*(1 - x2 - x4 - x5)^3*

(b3 + 2*(-1 + x3 + x5)))/(e1^4*(1 + (1 - x2 - x4 - x5)^4/e1^4)^

2))*x9)/(12*(1 + x10 + x11 + x12 + x7 + x8 + x9)),

((-12*x12)/(1 + (1 - x1 - x3 - x5)^4/e1^4) -

(12*x11)/(1 + (1 - x1 - x3 - x6)^4/e1^4) -

(48*x11*(1 - x1 - x3 - x6)^3*(-1 + x1 + x6))/

(e1^4*(1 + (1 - x1 - x3 - x6)^4/e1^4)^2) -

(6*x12*(-b1 + (b1 + 2*(-1 + x1 + x6))/(1 + (1 - x1 - x3 - x5)^4/

e1^4)))/e3 - 6*(2/(1 + (1 - x2 - x4 - x6)^4/e1^4) +

(4*(1 - x2 - x4 - x6)^3*(b3 + 2*(-1 + x1 + x6)))/

(e1^4*(1 + (1 - x2 - x4 - x6)^4/e1^4)^2))*x7 -

(12*x8)/(1 + (1 - x1 - x4 - x6)^4/e1^4) -

(48*(1 - x1 - x4 - x6)^3*(-1 + x1 + x6)*x8)/

(e1^4*(1 + (1 - x1 - x4 - x6)^4/e1^4)^2))/

(12*(1 + x10 + x11 + x12 + x7 + x8 + x9)) -

(x12*(-6*x10*(-b1 + (b1 - 2*x4)/(1 + (1 - x2 - x3 - x5)^4/e1^4)) -

(12*x11*(-1 + x1 + x6))/(1 + (1 - x1 - x3 - x6)^4/e1^4) -

6*x12*(-b1 + (b1 + 2*(-1 + x1 + x6))/(1 + (1 - x1 - x3 - x5)^4/

e1^4)) - 6*(-b3 + (b3 + 2*(-1 + x1 + x6))/

(1 + (1 - x2 - x4 - x6)^4/e1^4))*x7 - (12*(-1 + x1 + x6)*x8)/

(1 + (1 - x1 - x4 - x6)^4/e1^4) -

6*(-b3 + (b3 - 2*x3)/(1 + (1 - x2 - x4 - x5)^4/e1^4))*x9))/

(12*e3*(1 + x10 + x11 + x12 + x7 + x8 + x9)^2),

((-6*E^(x2/e3)*(-b2 + (b2 - 2*x2)/(1 + (1 - x1 - x4 - x6)^4/e1^4)) -

6*E^(x1/e3)*(-b3 + (b3 - 2*x1)/(1 + (1 - x2 - x4 - x6)^4/e1^4)))*

(1 + x10 + x11 + x12 + x7 + x8 + x9) - (E^(x1/e3) + E^(x2/e3))*

((-12*x12*(-1 + x3 + x5))/(1 + (1 - x1 - x3 - x5)^4/e1^4) -

(12*x10*(-1 + x3 + x5))/(1 + (1 - x2 - x3 - x5)^4/e1^4) -

6*x11*(-b2 + (b2 + 2*(-1 + x3 + x5))/(1 + (1 - x1 - x3 - x6)^4/

e1^4)) - 6*(-b3 + (b3 - 2*x1)/(1 + (1 - x2 - x4 - x6)^4/e1^4))*

x7 - 6*(-b2 + (b2 - 2*x2)/(1 + (1 - x1 - x4 - x6)^4/e1^4))*x8 -

6*(-b3 + (b3 + 2*(-1 + x3 + x5))/(1 + (1 - x2 - x4 - x5)^4/e1^4))*

x9))/(12*(1 + x10 + x11 + x12 + x7 + x8 + x9)^2),

((-6*E^(x4/e3)*(-b1 + (b1 - 2*x4)/(1 + (1 - x2 - x3 - x5)^4/e1^4)) -

6*E^(x3/e3)*(-b3 + (b3 - 2*x3)/(1 + (1 - x2 - x4 - x5)^4/e1^4)))*

(1 + x10 + x11 + x12 + x7 + x8 + x9) - (E^(x3/e3) + E^(x4/e3))*

(-6*x10*(-b1 + (b1 - 2*x4)/(1 + (1 - x2 - x3 - x5)^4/e1^4)) -

(12*x11*(-1 + x1 + x6))/(1 + (1 - x1 - x3 - x6)^4/e1^4) -

6*x12*(-b1 + (b1 + 2*(-1 + x1 + x6))/(1 + (1 - x1 - x3 - x5)^4/

e1^4)) - 6*(-b3 + (b3 + 2*(-1 + x1 + x6))/

(1 + (1 - x2 - x4 - x6)^4/e1^4))*x7 - (12*(-1 + x1 + x6)*x8)/

(1 + (1 - x1 - x4 - x6)^4/e1^4) -

6*(-b3 + (b3 - 2*x3)/(1 + (1 - x2 - x4 - x5)^4/e1^4))*x9))/

(12*(1 + x10 + x11 + x12 + x7 + x8 + x9)^2),

((-6*E^(x5/e3)*(-b2 + (b2 - 2*x5)/(1 + (1 - x1 - x3 - x6)^4/e1^4)) -

6*E^(x6/e3)*(-b1 + (b1 - 2*x6)/(1 + (1 - x1 - x3 - x5)^4/e1^4)))*

(1 + x10 + x11 + x12 + x7 + x8 + x9) - (E^(x5/e3) + E^(x6/e3))*

(-6*x10*(-b1 + (b1 + 2*(-1 + x2 + x4))/(1 + (1 - x2 - x3 - x5)^4/

e1^4)) - 6*x11*(-b2 + (b2 - 2*x5)/(1 + (1 - x1 - x3 - x6)^4/

e1^4)) - 6*x12*(-b1 + (b1 - 2*x6)/(1 + (1 - x1 - x3 - x5)^4/

e1^4)) - (12*(-1 + x2 + x4)*x7)/(1 + (1 - x2 - x4 - x6)^4/

e1^4) - 6*(-b2 + (b2 + 2*(-1 + x2 + x4))/

(1 + (1 - x1 - x4 - x6)^4/e1^4))*x8 - (12*(-1 + x2 + x4)*x9)/

(1 + (1 - x2 - x4 - x5)^4/e1^4)))/

(12*(1 + x10 + x11 + x12 + x7 + x8 + x9)^2)}

sqsum[kk_] := Module[{r, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12},

{f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12} = kk;

r = f1*f1 + f2^2 + f3*f3 + f4^2 + f5*f5 + f6^2 + f7^2 + f8*f8 + f9*f9 +

f10*f10 + f11^2 + f12^2; Return[r]; ]

s3sum[kk_] := Module[{r, f1, f2, f3}, {f1, f2, f3} = kk; r = f1 + f2 + f3;

Return[r]; ]

posqq = {1 - x2 - x4 - x6, 1 - x1 - x4 - x6, 1 - x2 - x4 - x5,

1 - x2 - x3 - x5, 1 - x1 - x3 - x6, 1 - x1 - x3 - x5}

pay3 = {((-2*x12*(-1 + x3 + x5))/(1 + (1 - x1 - x3 - x5)^4/e1^4) -

(2*x10*(-1 + x3 + x5))/(1 + (1 - x2 - x3 - x5)^4/e1^4) -

x11*(-b2 + (b2 + 2*(-1 + x3 + x5))/(1 + (1 - x1 - x3 - x6)^4/e1^4)) -

(-b3 + (b3 - 2*x1)/(1 + (1 - x2 - x4 - x6)^4/e1^4))*x7 -

(-b2 + (b2 - 2*x2)/(1 + (1 - x1 - x4 - x6)^4/e1^4))*x8 -

(-b3 + (b3 + 2*(-1 + x3 + x5))/(1 + (1 - x2 - x4 - x5)^4/e1^4))*x9)/

(2*(1 + x10 + x11 + x12 + x7 + x8 + x9)),

(-(x10*(-b1 + (b1 - 2*x4)/(1 + (1 - x2 - x3 - x5)^4/e1^4))) -

(2*x11*(-1 + x1 + x6))/(1 + (1 - x1 - x3 - x6)^4/e1^4) -

x12*(-b1 + (b1 + 2*(-1 + x1 + x6))/(1 + (1 - x1 - x3 - x5)^4/e1^4)) -

(-b3 + (b3 + 2*(-1 + x1 + x6))/(1 + (1 - x2 - x4 - x6)^4/e1^4))*x7 -

(2*(-1 + x1 + x6)*x8)/(1 + (1 - x1 - x4 - x6)^4/e1^4) -

(-b3 + (b3 - 2*x3)/(1 + (1 - x2 - x4 - x5)^4/e1^4))*x9)/

(2*(1 + x10 + x11 + x12 + x7 + x8 + x9)),

(-(x10*(-b1 + (b1 + 2*(-1 + x2 + x4))/(1 + (1 - x2 - x3 - x5)^4/

e1^4))) - x11*(-b2 + (b2 - 2*x5)/(1 + (1 - x1 - x3 - x6)^4/

e1^4)) - x12*(-b1 + (b1 - 2*x6)/(1 + (1 - x1 - x3 - x5)^4/

e1^4)) - (2*(-1 + x2 + x4)*x7)/(1 + (1 - x2 - x4 - x6)^4/e1^4) -

(-b2 + (b2 + 2*(-1 + x2 + x4))/(1 + (1 - x1 - x4 - x6)^4/e1^4))*x8 -

(2*(-1 + x2 + x4)*x9)/(1 + (1 - x2 - x4 - x5)^4/e1^4))/

(2*(1 + x10 + x11 + x12 + x7 + x8 + x9))}

shapval = {1/3 + (-2*b1 + b2 + b3)/6, 1/3 + (b1 - 2*b2 + b3)/6,

1/3 + (b1 + b2 - 2*b3)/6}

nucleo = {1/3, 1/3, 1/3}

memo = {nucleolus,value,vector,is,correct,ONLY,when,b1b2b3,quantities,

are,small,enough}

subcos = {-(x10*(-1 + (1 + (-1 + x2 + x3 + x5)^4/e1^4)^(-1))*

(-3*(-2 + x11 + x12) + (-3 + 2*x11 + 2*x12)*x7 +

(-3 + 2*x11 + 2*x12)*x8) +

x12*(-1 + (1 + (-1 + x1 + x3 + x5)^4/e1^4)^(-1))*

(-3*(-2 + x10 + x9) + x7*(-3 + 2*x10 + 2*x9) +

x8*(-3 + 2*x10 + 2*x9)))/(6*(1 - (-1 + e4)*(-1 + x11 + x12)*

(-1 + x7 + x8)*(-1 + x10 + x9))),

-((-1 + (1 + (-1 + x1 + x4 + x6)^4/e1^4)^(-1))*x8*(-3*(-2 + x11 + x12) +

x10*(-3 + 2*x11 + 2*x12) + (-3 + 2*x11 + 2*x12)*x9) +

x11*(-1 + (1 + (-1 + x1 + x3 + x6)^4/e1^4)^(-1))*

(-3*(-2 + x7 + x8) + x10*(-3 + 2*x7 + 2*x8) + (-3 + 2*x7 + 2*x8)*

x9))/(6*(1 - (-1 + e4)*(-1 + x11 + x12)*(-1 + x7 + x8)*

(-1 + x10 + x9))), -((-1 + (1 + (-1 + x2 + x4 + x5)^4/e1^4)^(-1))*

(-3*(-2 + x7 + x8) + x11*(-3 + 2*x7 + 2*x8) +

x12*(-3 + 2*x7 + 2*x8))*x9 + (-1 + (1 + (-1 + x2 + x4 + x6)^4/e1^4)^

(-1))*x7*(-3*(-2 + x10 + x9) + x11*(-3 + 2*x10 + 2*x9) +

x12*(-3 + 2*x10 + 2*x9)))/(6*(1 - (-1 + e4)*(-1 + x11 + x12)*

(-1 + x7 + x8)*(-1 + x10 + x9)))}

nnn = (1 - x11 - x12)*(1 - x7 - x8)*(1 - x10 - x9)

end = lastline

///////////////////////////////////////////////////////////////////////////////////

{Second part is of MATHEMATICA file "e1seq2.s19".}

///////////////////////////////////////////////////////////////////////////////////

e1seq2[tsa_, e10_, ie1inc_, st_Integer, st2_Integer, sx0_, acc_Integer] :=

Module[{ffav, ct, ct2, s, sxva, e1v, ie1v, r}, ffav = ff0 /. tsa; ct = 0;

ct2 = 0; sxva = sx0; e1v = e10; r = {e10, sx0}; ie1v = 1/e1v;

Label[o1]; ie1v = ie1v + ie1inc; e1v = 1/ie1v;

sxva = sxstep[sxva, e1v, ffav, acc]; ct = ct + 1; ct2 = ct2 + 1;

If[ct2 < st2, Goto[o1]]; ct2 = 0; r = r + u^ct*{e1v, sxva};

If[ct < st, Goto[o1]]; Return[r]; ]

sxstep[insx_, e1a_, ffa_, acc_] := Module[{sxv}, ff = ffa /. e1 -> e1a;

f = sqsum[ff]; sxv = rrs[insx, acc - 3, 2]; sxv = N[sxv, acc - 5];

sxv = FRTB[ff, sxv, acc]; sxv = N[sxv, acc - 3]; Return[sxv]; ]

//////////////////////////////////////////////////////////////////////////////

{Third part is of MATHEMATICA file "eeseq2.d.419".}

////////////////////////////////////////////////////////////////////////////

eeseq2[tsb_, e10_, e30_, k1_, k2_, j_, st_Integer, st2_Integer, sx0_,

acc_Integer] := Module[{ffav, ct, ct2, sxva, e1v, e3v, r},

ffav = ff0 /. tsb; ct = 0; ct2 = 0; sxva = sx0; e1v = e10; e3v = e30;

r = {e10, e30, sx0}; Label[o1]; {e1v, e3v} = eestep2[e1v, e3v, k1, k2, j];

sxva = sxstep[sxva, e1v, e3v, ffav, acc]; ct = ct + 1; ct2 = ct2 + 1;

If[ct2 < st2, Goto[o1]]; ct2 = 0; r = r + u^ct*{e1v, e3v, sxva};

If[ct < st, Goto[o1]]; Return[r]; ]

eestep2[a1_, a2_, k1_, k2_, j_] := Module[{b1, b2, s1, s2, r},

b1 = 1/a1; b2 = 1/a2; s1 = k1*(b1^j); s1 = IntegerPart[s1];

s2 = k2*(b2^j); s2 = IntegerPart[s2]; b1 = b1 + s1; b2 = b2 + s2;

r = {1/b1, 1/b2}; Return[r]; ]

sxstep[insx_, e1a_, e3a_, ffa_, acc_] := Module[{sxv},

ff = ffa /. {e1 -> e1a, e3 -> e3a}; f = sqsum[ff];

sxv = rrs[insx, acc - 3, 2]; sxv = N[sxv, acc - 5];

sxv = FRTB[ff, sxv, acc]; sxv = N[sxv, acc - 3]; Return[sxv]; ]

///////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////

Five cases of results of calculations:

Case 1:

totsubs = {e1 -> 1/2192, e3 -> 1/166,

b1 -> 1/7, b2 -> 1/6, b3 -> 1/5}

sxa = {0.363559352305709551694991958226659`20,

0.363557921561076956001638696615708`20,

0.339974708654198381213502283077245`20,

0.339972443473879056467419163955302`20,

0.296431911373261784065389274671264`20,

0.296431119209088920021658682547455`20,

2114.6779064860315699408562820565`20,

2114.175722488961998308090839074`20,

2293.1560625771558379268627372806`20,

2292.2939522836141951609922371819`20,

2746.1508802433459446029790820789`20,

2745.7897871970582507309309568302`20}

pp = {0.3635458240261748, 0.33996306643187385,

0.29642441745726816}

SVa = {0.3468253968253968, 0.3349206349206349,

0.31825396825396823}

SVe = {437/1260, 211/630, 401/1260}

ptot = 0.9999333079153168

Probabilities of the various coalitions

forming in the process:

prob23coal = co1 = 0.3521597723247086

prob13coal = co2 = 0.3397346289481023

prob12coal = co3 = 0.3081055987271891

///////////////////////////////////////////////

Case 2:

totsubs = {e1 -> 1/867, e3 -> 1/77,

b1 -> 1/4, b2 -> 2/7, b3 -> 1/3}

sxa = {0.391848779440067626885604722563224`20,

0.391838792789722496908362650482066`20,

0.348185006310385605243056160861924`20,

0.348168443075420224049219255232638`20,

0.259852896706008588928392478345275`20,

0.259847945975483797940930658085593`20,

527.7087454188208884027418298066`20,

527.3031081108992781729154784539`20,

600.5872699971815415273494861138`20,

599.8217877957068774249296739488`20,

902.8550779742111180049136140675`20,

902.5109695675787430849845453482`20}

pp = {0.3917925682555118, 0.3481425324376593,

0.2598376745448060}

SVa = {0.3531746031746032, 0.3353174603174603,

0.3115079365079365}

SVe = {89/252, 169/504, 157/504}

ptot = 0.9997727752379771

Probabilities that various 2-coalitions form by

elections of agencies:

prob23coal = co1 = 0.3699609884935736

prob13coal = co2 = 0.3521874455795275

prob12coal = co3 = 0.2778515659268989

////////////////////////////////////////////

Case 2B:

(with "epsilons" e1 and e3 very large)

totsubs = {e1 -> 1/2, e3 -> 1/2,

b1 -> 1/4, b2 -> 2/7, b3 -> 1/3}

sxa =

{0.289762698235241678903253034842157`20,

0.311748225465505655739634105353023`20,

0.131303400034321945655721838169235`20,

0.107881131440708460301066495019401`20,

0.2415810569884195428488739633087`20,

0.21354615875616631580118705762005`20,

0.050507929199458523786204438319956`20,

0.052778367074971281320283009340478`20,

0.325377119449252628055040242879522`20,

0.31048647447960870345594601800329`20,

0.174022704589430494993878577286076`20,

0.16453379344494918071376029220869`20}

pp = {0.26436832085030676,

0.12415896628644767, 0.20930891689734232}

ptot = 0.5978362040340968

2-person coalition formation chances:

23coal = 0.44076965035100063

13coal = 0.21044792360865588

12coal = 0.3487824260403435

///////////////////////////////////////////////

Case 3:

totsubs = {e1 -> 1/6277, e3 -> 1/216,

b1 -> 1/3, b2 -> 5/11, b3 -> 3/5}

sxa = {0.432741371214613335476238648836203`20,

0.432736446017547789566775153071029`20,

0.448243451742605418601599532791267`20,

0.44824098057847843866062441854525`20,

0.119008427696889402521026093966642`20,

0.119007419846927669033216991490659`20,

2167.4794365988075388933530908816`20,

2165.1748058124042760059764863235`20,

3302.4971739343375818023567458945`20,

3300.7348656012511820560325232082`20,

12998.7203735390182610390443178679`20,

12995.8909174067480673389179054936`20}

pp = {0.432731729824114880311867799299822`20,

0.448233549334670829751655363012704`20,

0.119008304902781656769637703466959`20}

SVa = {0.397979797979798, 0.3373737373737374,

0.26464646464646463}

SVe = {197/495, 167/495, 131/495}

ptot = 0.999973584061567366833160865779485`20

Probabilities that various 2-coalitions form

by elections of agencies:

prob23coal = co1 = 0.44127826197960357

prob13coal = co2 = 0.41060630578890184

prob12coal = co3 = 0.14811543223149462

///////////////////////////////////////////////////

Case 1B:

totsubs =

{e1->1/118, e3->1/722, b1->1/7, b2->1/6, b3->1/5}

sxa = {0.3410830223133562, 0.3410717675905068,

0.33387899114519043, 0.33385976223535485,

0.3234680628590915, 0.3234600963630246,

51.68058669482268, 51.26233653688477,

54.16719134660171, 53.420369607338536,

57.36480199592629, 57.03579763731401}

pp = {0.34075889426109785645331479377189`20,

0.333562147199287823238751413389702`20,

0.323171741421957822798294768067045`20}

ptot = 0.997492782882343502490360975228637`20

SVa = {0.34682539682539682540,

0.33492063492063492063,

0.31825396825396825397}

SVe = {437/1260, 211/630, 401/1260}