Élections, théorie du choix social et Go

Un peu de théorie du choix social…

17

- Universalité : l’élection doit toujours aboutir à un résultat, peu importe les candidats et votants
- Unanimité : si tous les votants préfèrent Jonathan Cohen à Emmanuel Macron, alors Jonathan Cohen doit devenir Président de la République
- IAND (Indépendance des Alternatives Non-Disponibles) : si les votants préfèrent un candidat à un autre, alors l’entrée d’un nouveau candidat dans la course ne devrait pas altérer cette préférence (ce qui est en principe assez difficile à vérifier)
- Absence de Dictateur : la règle de choix social n’obéit à aucun individu

type Candidate struct {
   Id   int
   Name string
}

type Voter struct {
   Id   int
   Name string
   Vote ScrutinIndiv
}

type Result struct {
   DuelsWon    int
   TotalPoints int
   WonAgainst  []Candidate
}

type ResultPerCandidate struct {
   Cand Candidate
   Res  Result
}

type Pair struct {
   L Candidate
   R Candidate
}

type ScrutinIndiv []Candidate

Le scrutin uninominal majoritaire à deux tours 🇫🇷

- 20 votants ayant la préférence C > A > D > B
- 12 votants ayant B > A > C > D
- 10 votants ayant A > D > B > C

func TwoRoundSystem(voters []model.Voter, c []model.Candidate) model.ResultList {
   count := make(map[model.Candidate]int)

   secondRoundList := make([]model.Candidate, 0)
   // Appel à une fonction de service qui va simuler le scrutin
   // en suivant ses règles
   firstRoundResult := majorityProcedure(voters, c, count)

   if len(firstRoundResult) == 1 {
       return firstRoundResult
   } else {
       for i := range firstRoundResult {
           secondRoundList = append(secondRoundList, firstRoundResult[i].Cand)
            // Appel recursif avec les candidats qualifiés au
            // second tour
           finalRes := TwoRoundSystem(voters, secondRoundList)
           return finalRes
       }
   }
   return model.ResultList{}
}

func majorityProcedure(voters []model.Voter, candidates []model.Candidate, res map[model.Candidate]int) model.ResultList {
   resultList := make(model.ResultList, len(res))
   resPair := make(model.ResultList, 0)
   total := 0

   for _, v := range voters {
       for i, alternative := range candidates {
            // On parcourt les choix de chaque votant
           if v.Vote.IndexOf(candidates[i]) == alternative.Id {
               res[alternative] += 1
               total++
           }
       }
   }
   for k, v := range res {
       // On affecte à chaque candidat le nombre de voix récoltées
       resultList = append(resultList, model.ResultPerCandidate{
           Cand: k,
           Res: model.Result{
               TotalPoints: v,
           },
       })
   }

   sort.Sort(sort.Reverse(resultList))
   // Ballot est une fonction dont le comportement dépend de la méthode
   // choisie (implémentation détaillée sur le repository GitHub)
   resPair, shouldReturn, returnValue := model.Ballot("majority", resultList, total, resPair, candidates)
   if shouldReturn {
       return returnValue
   }
   return resPair
}

Le vote par approbation

// La différence avec le vote majoritaire réside ici, dans la fonction Ballot
func Ballot(votingMethod string, resultList ResultList, total int, resPair ResultList, candidates []Candidate) (ResultList, bool, ResultList) {
   for cand := range resultList {
       percentage := (resultList[cand].Res.TotalPoints * 100) / total
       if percentage > 50 {
           resPair = append(resPair, ResultPerCandidate{
               Cand: resultList[0].Cand,
               Res: Result{
                   TotalPoints: resultList[0].Res.TotalPoints,
               },
           })
           return nil, true, resPair
       } else {
           for i := 0; i < len(candidates)-1; i++ {
               // Disjonction de cas entre l’approbation et le vote majoritaire
               if votingMethod == "approval" {
                   resPair = append(resPair, resultList[i])
               } else if votingMethod == "majority" {
                   resPair = append(resPair, resultList[0], resultList[1])
               }
               return nil, true, resPair
           }
       }
   }
   return resPair, false, nil
}

La méthode de Condorcet

func CondorcetVoteRound(votes []model.Voter, candidates []model.Candidate) (model.Candidate, model.Result) {
   now := time.Now()

   possiblePairDiff, resultList := model.GeneratePossiblePairDiffsAndResultList(candidates)
   // On récupère le score de chaque duel pour chacun des votants
   fmt.Println("---- before setPossiblePairDiffValue", time.Since(now))
   model.SetPossiblePairDiffValue(possiblePairDiff, votes)
   fmt.Println("--- after setPossiblePairDiffValue", time.Since(now))
   now = time.Now()
   // Liste des résultats
   model.SetResultListValue(possiblePairDiff, resultList)
   now = time.Now()
   // On récupère un gagnant
   var result model.Result = model.Result{}
   var candidat model.Candidate = model.Candidate{}
   for r, v := range resultList {
       if result.DuelsWon < v.DuelsWon {
           result = *v
           candidat = r
       }
   }
   return candidat, result
}

La méthode de Copeland

- (+1) si i est strictement préféré au candidat j pour l’ensemble des électeurs
- (-1) si j est strictement préféré à i

// Petit tricks : Calculer le score de Copeland à partir d’un vote
// de Condorcet pour s’affranchir de la manipulation matricielle
func Copeland(voters []model.Voter, candidates []model.Candidate) (model.Candidate, int) {
   numberOfDuels := len(candidates) - 1
   candidat, result := CondorcetVoteRound(voters, candidates)
   duelLost := numberOfDuels - result.DuelsWon

   // result.DuelsWon - duelLost correspond au score de Copeland
   return candidat, result.DuelsWon - duelLost

}

Vers un changement du mode de scrutin en France ?