Gambling pool — ecyglpki 0.2.0 documentation

### Navigation

- index
- modules |
- previous |
- ecyglpki 0.2.0 documentation »
- Examples »

# Gambling pool

`gambling_pool.` `pspace` = ('W', 'D', 'L')

  The set of possible football match outcomes (Win, Draw, or Lose)

class `gambling_pool.` `Gamble`

  Gamble on the outcome of a football match

  With each possible match outcome, the gamble assigns a payoff (a `Real`); it corresponds to winnings if it is positive, to losses if it is negative.

  `D`

    Alias for field number 1

  `L`

    Alias for field number 2

  `W`

    Alias for field number 0

`gambling_pool.` `lp_setup`(lp, accdss)

  Set up the basic linear feasibility problem defining the gambling pool

  A number of players will form a gambling pool:

  > - Each player states which gambles he finds acceptable, i.e., which have an expected payoff that is nonnegative
  > - If there is a bet between the players, a gamble is assigned to each of them; from the player’s perspective, the assigned gamble should be acceptable, meaning that is a positive linear combination of the gambles that that player has stated to be acceptable
  > - The stake is assumed to be one, i.e., the assigned gamble’s lowest payoff is -1.
  > - There is a bet between the players if the gambles assigned to the players sum up to one for each possible match outcome and the assigned gambles do not all have identically zero payoff
  > - An important quantity for each player is the ‘lower prevision’ of the gamble assigned to him: the greatest lower bound on the player’s expected payoff for the assigned gamble that can be deduced from the player’s stated acceptable gambles
  > - The objective is to maximize the sum of the lower previsions, possibly under additional constraints

  Parameters: | lp (`ecyglpki.Problem`) – the problem object to set up accdss (`dict` of `str` (player id) to `list` of `Gamble`) – the gambles accepted by the players
  Returns: | the set up problem object
  Return type: | `ecyglpki.Problem`

`gambling_pool.` `lp_assign`(accdss)

  Assign gambles to all players that maximize the sum of lower previsions

  Parameters: | accdss (`dict` of `str` (player id) to `list` of `Gamble`) – the gambles accepted by the players
  Returns: | the gamble assigned to the players and the corresponding lower prevision value
  Return type: | `dict` of `str` (player id) to {`'gamble'`: `Gamble`, `'lpr'`: `float`}

      >>> Agambles = [Gamble(.5, .25, -1), Gamble(1, -1, -1)]
      >>> Bgambles = [Gamble(-1, -1, 2), Gamble(1, .5, -.25)]
      >>> Cgambles = [Gamble(-1, 0, -1)]
      >>> accdss = {'Alice': Agambles, 'Bob': Bgambles, 'Cthulhu': Cgambles}
      >>> solution = lp_assign(accdss)
      >>> assert solution == (
      ...     {'Alice': {'gamble': Gamble(W=2.0, D=-1.0, L=-1.0), 'lpr': 0.5},
      ...      'Bob': {'gamble': Gamble(W=-1.0, D=-1.0, L=2.0), 'lpr': 0.0},
      ...      'Cthulhu': {'gamble': Gamble(W=-1.0, D=2.0, L=-1.0), 'lpr': 2.0}}
      ... )

`gambling_pool.` `milp_assign`(accdss)

  Assign gambles to some players that maximize the sum of lower previsions

  As compared to `lp_assign`, we now try to make the bet fair in the sense that for each player the lower prevision for the assigned gamble is equal to the other player’s lower prevision, or the gamble assigned to the player is zero for all outcomes.

  Parameters: | accdss (`dict` of `str` (player id) to `list` of `Gamble`) – the gambles accepted by the players
  Returns: | the gamble assigned to the players and the corresponding lower prevision value
  Return type: | `dict` of `str` (player id) to {`'gamble'`: `Gamble`, `'lpr'`: `float`}

      >>> Agambles = [Gamble(.5, .25, -1), Gamble(1, -1, -1)]
      >>> Bgambles = [Gamble(-1, -1, 2), Gamble(1, .5, -.25)]
      >>> Cgambles = [Gamble(-1, 0, -1)]
      >>> accdss = {'Alice': Agambles, 'Bob': Bgambles, 'Cthulhu': Cgambles}
      >>> solution = milp_assign(accdss)
      >>> for player, data in solution.items():  # round floats for doctest
      ...     solution[player]['lpr'] = round(data['lpr'], 2)
      ...     solution[player]['gamble'] = Gamble(round(data['gamble'].W, 2),
      ...                                         round(data['gamble'].D, 2),
      ...                                         round(data['gamble'].L, 2))
      >>> assert solution == (
      ...     {'Alice': {'gamble': Gamble(W=1.4, D=0.0, L=-1.0), 'lpr': 0.4},
      ...      'Bob': {'gamble': Gamble(W=-0.4, D=-0.4, L=2.0), 'lpr': 0.4},
      ...      'Cthulhu': {'gamble': Gamble(W=-1.0, D=0.4, L=-1.0), 'lpr': 0.4}}
      ... )

### Navigation

- index
- modules |
- previous |
- ecyglpki 0.2.0 documentation »
- Examples »