# Help

## Contents

1. Quick Start Guide
2. Syntax
3. Glossary

## Quick Start Guide

Suppose players 1,..,n and each of them can say "yes" or "no". Each such player i is represented by a Boolean variable xi which can be 1 ("yes") or 0 ("no").

Now consider a set of m -constraints and non-negative integer coefficients wi,j ("weights"), where i is the player and j is the constraint:

w1,1xi + ... + w1,nxn ≥ Q1
...
wm,1x1 + ... + wm,nxn ≥ Qm

One such constraint is called a Weighted Voting Game (WVG) and a satisfying coalition is called a winning coalition (of players). If a coalition is winning only if is satisfies all m constraints, then it is called Multiple Weights Voting Game (MWVG).

To model a MWVG as input for the laboratory the constraints have to be transposed as shown below. The main advantage of this representation is that we can now add the names of the players. You should keep in mind that the input is player-oriented:

Q1 ... Qm
w1,1 ... wm,1 Name of the 1-st Player
...
w1,n ... wm,n Name of the n-th Player
The weights on a players' line can be separated by any number of spaces and tabs. The players' name ends at the end of the line.

As an example, consider the following two constraints:

1x1 + 1x2 + 1x3 ≥ 2 1x1 + 2x2 + 3x3 ≥ 3
This can be modeled as:
```# Right hand sides:
2  3
# Weights and names. Here: A, B, C
1  3 A
1  2 B
1  1 C
```

## Syntax

The input format is made of lines. There are four types of lines: Blanks, comments, commands, quotas and classes.
• Blank lines (lines which contain only spaces and tabs) are ignored.
• A comment line beginning with # is ignored.
• A command line begins with a %% and has the form %<name> <value> where <name is the command''s name and <command> is the optional value that is passed to the command. For a list of commands, see below.
• The quota line, which has to appear before any class line, contains the integer quotas for each constraint. The number of quotas determines the number of constraints.
• A class line adds a new class of players to the game and sets its weights for the constraints. This type of line is discussed in more detail below.

### Classes

A class line has the form

```	(x<multiplier>) <weights> (<name>)
```
where (...) indicates an optional part. The multiplier indicates the number of players in the class. For instance, x5 indicates 5 players. If no multiplier is given, x1 is assumed.

The <weights> has to provide a non-negative integer weight for each constraint.

The <name> is an optional name for the player. There are no restrictions for its form. The name ends at the end of the line.

### Commands

#### %join <bool expr>

The join command provides a Boolean expression which describes how to join the constraints. The variables are the m constraints numbered from 1 to m. Boolean operations are AND and OR. Negation is not allowed. The parser respects precedence of conjunction over disjunction and recognizes brackets.

Multiple occurrences of a variable are allowed. See also the example of the US Federal Legal System below.

### Examples

The prominent UN Security Council contains five permanent players each of which has veto power and it contains ten non-permanent players. For a resolution to pass, nine members have to vote in favor for it. This situation if often modeled as binary game with only "yes" and "no" votes. A weighted representation is [39;7,7,7,7,7,1,1,1,1,1,1,1,1,1,1]. If we do not care on the members names, we can model it as:
```# UN Security Council - First version
39
x5   7 Permanent Member
x10   1 Non-permanent Member
```
If we do care on the names of the permanent members we could model:
```# UN Security Council - Second version
39
7 United States
7 Russia
7 China
7 France
7 United Kingdom
x10   1 Non-permanent Member
```
Even though the weighted representation is well known for this game, the fact that we express two different rules (veto power and "9 out of 15") in a single constraint it not optimal. For example, consider the following model which uses two constraints:
```# UN Security Council - Third version
5  9
x5   1  1 Permanent Member
x10   0  1 Non-permanent Member
```
This model is much more obvious in that the first constraint models veto power of the permanent members and the second models the "9 out of 15" rule.

We now consider a more complicated example, viz. the US Federal Legal System. The players are the 100 members of the senate, the 435 members of the house of representatives, the president of the United States and the vice president of the United States which is the president of the senate. A bill passes if at least one of the following conditions is satisfied:

• 51 senators and 218 representatives vote in favor and the president does not veto the bill.
• 50 senators, the vice president and 218 representatives vote in favor and the president does no veto it.
• 67 senators and 290 representatives approve the bill.
As the president of the senate, the vice president acts as a tie-breaker if the senators are equally divided. He does not have a regular vote. The game can be modeled using seven simple rules:
1. The president approves.
2. At least 51 senators approve.
3. At least 218 representatives approve.
4. The vice president approves.
5. At least 50 senators approve.
6. At least 67 senators approve.
7. At least 290 representatives approve.
From the description of the game above, a bill passes if
• the rules 1, 2 and 3 are fulfilled, or
• the rules 1, 4, 5 and 3 are fulfilled, or
• the rules 6, 7 are fulfilled.
Straight from that we can derive the model of our game. The join command in the first line relates the single rules as stated above.
```%join (1 AND 2 AND 3) OR (1 AND 4 AND 5 AND 3) OR (6 AND 7)
1  51 218  1  50  67  290
x100 0   1   0  0   1   1    0 Member of the Senate
x435 0   0   1  0   0   0    1 Member of the House of Rep.
1   0   0  0   0   0    0 President
0   0   0  1   0   0    0 Vice-President
```

## Glossary

### Simple Game

Let n ≥ 1 and N={1,…,n} and W ⊆ 2N. The pair (N,W) is called a simple game if
1. ∅ ∉ W,
2. N ∈ W (not-empty) and
3. ∀ S,T ∈ 2N, S ⊆ T: S ∈ W ⇒ T ∈ W (up-set)
The elements in N are called players. Subsets of 2N are called coalitions. A coalition S is called winning if S ∈ W and it is called losing otherwise. A coalition S ∈ W is called minimal winning if each proper subset is losing. The set of minimal winning coalition is denoted by Wmin. A coalition S is blocking if N \ S is losing. In the remainder, let (N,W) be a simple game.

### (Multiple) Weighted Voting Games

Let Q ≥ 1 and w1,…,wn≥ 0 be integers. We call [Q;w1,…,wn] a weighted representation (of (N,W)) if

∀ S ∈ 2N: ∑i ∈ S wi ≥ Q ⇔ S ∈ W.

In this case, the Q is called the quota and w1,…,wi are called the weights (of the players). For S∈ 2N we define w(S):=∑i∈ S wi. A weighted representation [Q;w1,…,wn] is called homogeneous if for each minimal winning coalition S it holds w(S)=Q. For instance, [8;6,4,3,1] and [5;3,2,2,1] represent the same game, the former representation is not homogeneous while the latter is homogeneous. When we use vectors instead of scalar integers for the weights and for the quota we end up at multiple weighted voting games (Also known as vector-weighted voting games). Operations like + and are defined component-wise for this. For instance, the game [(2,3);(1,2),(2,1),(0,2),(1,1)] is not weighted.

### Players

The preorder I⊆ N2 is called the at-least-as-desirable relation (on individuals) and compares players with respect to their abilities. Given any two players i,j∈ N the relation is defined by

i≽I j ⇔ ∀ S ⊆ N\ {i,j}: S ∪ {j} ∈ W ⇒ S ∪ {i} ∈ W

Two players i,j ∈ N are called symmetric (denoted by i≈Ij) if i≽I j and j ≽I i. A player i ∈ N is called ...
• ... vetoer if ∀ S ∈ W: i ∈ W.
• ... dummy if ∀ S ∈ Wmin: i ∉ S.
• ... dictator if Wmin={i}. Same as N \ {i} are dummies and i is not.
If (N,W) has a homogeneous representation [Q;w1,…,wn] a non-dummy player i is called ...
• ... sum if

∃ S ∈ Wmin, i ∈ S: ∃ T ⊆ N \ S: (∀ j ∈ T: i ≽I j) ∧ (S \ {i}) ∪ T ∈ W.

There is a minimal winning coalition containing i in which i can be replaced by some not more desirable players such that the resulting coalition is winning again.
• ... step if it is not a sum.

### Types and Models

The equivalence classes of the players (called types) of a simple game (N,W) w.r.t I are denoted N1,...,Nt⊆ N where t (for types) denotes their number. Let A⊆ 2N be a set of coalitions. We call a vector (m1,...,mt)∈ ℕt a model of A if

∃ S ∈A : ∀ k=1,...,t : mk = |S ∩ Nk|.

Representions by models are often applied to the sets of the winning, the minimal winning and the shift-minimal winning coalitions. A simlar statement holds for the corresponding sets of the losing coalitions.

### Properties

The simple game (N,W) is called ...
• ... complete if I is total. Synonyms are total and swap-robust.
• ... directed if 1≽I 2 ≽I ··· ≽I n.
• ... consecutive if for each type k=1,...,t it holds Nk={min Nk,...,max Nk}. Directed games are always consecutive. Complete games are not.
• ... weighted if it has a weighted representation.
• ... homogeneous if it has a homogeneous weighted representation.
• ... proper if ∀ S ∈ W: N \ S ∉ W.
• ... strong if ∀ S ∉ W: N \ S ∉ W.
• ... decisive if it is proper and strong.