First Report on a Project Studying the Analysis of Cooperation 
        in Games Through 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 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

    It was a few years ago that I got what seemed like an inspired idea that
offered a means for studying cooperative (or "coalitional") games in a manner
with parallels to the ways by which theoretical biologists have studied the topic of "the evolution of cooperation" (Axelrod et al). The idea also offered an escape from all of the verbal complexities that might otherwise naturally attach to coalition possibilities because of the unlimited nature of the conceivable elaboration of verbal contracts.
    In effect the concept allows the game to be transformed into a game that is in certain senses equivalent and which is to be considered in the repeated game context that is directly analogous to the repeated game context studied 
by theoretical biologists studying the possibility of cooperation evolving in the context of a repeated game of "Prisoners' Dilemma" form.
    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 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 we find 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.
   //////////////////////////////////////////////
     (possibly incomplete topic above) 
  ///////////////////////////////////////////

                                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 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 noncooperative 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 "bargaining" game. 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 processing 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 Nash result for such a game according to "Two-Person Cooperative Games".
    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 description.
    And 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 studied in comparisons.

                      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 and times. We cam mention
representative names of persons doing research in these areas. Armando
Gomes has studied a model of cooperation which 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 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}