SocialChoice 03 : Méthodes de Vote et Paradoxes (twin C# .NET)

Twin C# .NET de GameTheory/SocialChoice/03-Voting-Methods.ipynb (marathon parite #4956). Kernel .net-csharp. Ce notebook compagnon du notebook 02 (Lean, preuves formelles) fournit les implementations C# from-scratch des méthodes de vote (Prong B, EPIC #3801). Le twin Python utilise numpy/matplotlib/networkx ; les visualisations sont remplacees par un rendu ASCII autonome.

Objectifs d’apprentissage

  1. Modeliser un profil de préférences collectives (classements individuels)
  2. Implementer les règles de vote : Pluralite, Borda, Copeland, Condorcet, IRV
  3. Illustrer les paradoxes : cycle de Condorcet, divergence des règles, theoreme de Sen
  4. Simuler empiriquement les violations de IIA (theoreme d’Arrow)
  5. Comprendre le theoreme de l’electeur median (préférences unimodales)
// SocialChoice 03 : Methodes de Vote et Paradoxes -- twin C# de 03-Voting-Methods
// Prong B (#3801) : implementations from-scratch des regles de vote (Pluralite, Borda,
// Copeland, Condorcet, IRV). Le twin Python (03-Voting-Methods.ipynb) est le compagnon
// du notebook 02 (Lean, preuves formelles) ; ce twin execute les memes algorithmes en C#.
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;

// Culture invariante : separateur decimal "." (parite de sortie avec le twin Python).
// Les 3 setters sont necessaires : .NET Interactive evalue les cellules sur des threads
// du pool distincts (CurrentCulture seul ne persiste pas cross-cell).
CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;

Console.WriteLine("Configuration OK : SocialChoice 03 - Methodes de Vote (twin C# .NET 9)");
Configuration OK : SocialChoice 03 - Methodes de Vote (twin C# .NET 9)
// === Section 1 : Profil de preferences ===
// Un profil = liste des classements (du meilleur au pire) de chaque votant.
// Equivalent C# de la classe Profile du twin Python / de la structure Lean Profile (SC-02).

static class Vote
{
    // Le votant i prefere-t-il x a y ? (x et y sont des indices d'alternatives)
    public static bool Prefers(List<List<string>> profile, int voter, string x, string y)
        => profile[voter].IndexOf(x) < profile[voter].IndexOf(y);

    // Majorite des votants prefere-t-elle x a y ?
    public static bool MajorityPrefers(List<List<string>> profile, string x, string y)
    {
        int xCount = profile.Count(p => p.IndexOf(x) < p.IndexOf(y));
        return xCount > profile.Count / 2.0;
    }

    // Resultat du duel majoritaire entre x et y : x, y, ou null (egalite)
    public static string PairwiseMajority(List<List<string>> profile, string x, string y)
    {
        int xWins = profile.Count(p => p.IndexOf(x) < p.IndexOf(y));
        int yWins = profile.Count - xWins;
        if (xWins > yWins) return x;
        if (yWins > xWins) return y;
        return null;
    }
}

// Profil de Condorcet (3 votants, cycle A>B>C / B>C>A / C>A>B)
var condorcetProfile = new List<List<string>>
{
    new() { "A", "B", "C" },
    new() { "B", "C", "A" },
    new() { "C", "A", "B" },
};

static void PrintProfile(string title, List<List<string>> profile)
{
    Console.WriteLine(title);
    Console.WriteLine(new string('=', 40));
    for (int i = 0; i < profile.Count; i++)
        Console.WriteLine($"  Votant {i + 1}: {string.Join(" > ", profile[i])}");
}

PrintProfile("PROFIL DE CONDORCET", condorcetProfile);
Console.WriteLine($"\nPareto(A, B) ici ? {Vote.PairwiseMajority(condorcetProfile, "A", "B")} (A bat B en duel)");
PROFIL DE CONDORCET
========================================
  Votant 1: A > B > C
  Votant 2: B > C > A
  Votant 3: C > A > B

Pareto(A, B) ici ? A (A bat B en duel)

1. Profil de préférences et paradoxe de Condorcet

Un profil décrit les classements (du meilleur au pire) de chaque votant. La structure Profile est l’équivalent C# de la structure Lean du notebook SC-02 : elle stocke, pour chaque votant, un ordre total sur les alternatives. C’est l’objet de départ de toute la théorie du vote — sans une représentation explicite des préférences individuelles, aucune règle d’agrégation n’est définissable.

Le paradoxe de Condorcet (1785) est le résultat fondateur qui motive toute cette section : avec seulement 3 alternatives et des préférences individuelles pourtant parfaitement rationnelles (chaque votant a un ordre strict et transitif), les duels majoritaires peuvent former un cycle (A bat B, B bat C, C bat A). La préférence collective n’est alors pas transitive alors que chaque préférence individuelle l’est — l’agrégation détruit une propriété que chaque individu respectait. C’est ce paradoxe qui rend impossible l’idée d’une règle de vote « parfaite » et qui mènera au théorème d’Arrow (§6).

// === Section 1 (suite) : Paradoxe de Condorcet et cycles ===
// On calcule tous les duels pairwise. S'il y a un cycle (A bat B, B bat C, C bat A),
// aucun gagnant de Condorcet n'existe.

static void CheckCondorcetCycle(List<List<string>> profile, List<string> alternatives)
{
    Console.WriteLine("Resultats pairwise :");
    for (int i = 0; i < alternatives.Count; i++)
        for (int j = i + 1; j < alternatives.Count; j++)
        {
            string x = alternatives[i], y = alternatives[j];
            string winner = Vote.PairwiseMajority(profile, x, y);
            Console.WriteLine($"  {x} vs {y}: {(winner ?? "egalite")}");
        }
}

CheckCondorcetCycle(condorcetProfile, new List<string> { "A", "B", "C" });
Console.WriteLine("\n=> CYCLE : A bat B, B bat C, C bat A ! (chacun 2-1)");

// Visualisation ASCII du cycle (remplace networkx du twin Python)
Console.WriteLine("\nGraphe oriente des duels (cycle) :");
Console.WriteLine("    A");
Console.WriteLine("   ^ \\");
Console.WriteLine("   |  v");
Console.WriteLine("   C <- B");
Console.WriteLine("   A > B, B > C, C > A  (cycle de longueur 3)");
Resultats pairwise :
  A vs B: A
  A vs C: C
  B vs C: B

=> CYCLE : A bat B, B bat C, C bat A ! (chacun 2-1)

Graphe oriente des duels (cycle) :
    A
   ^ \
   |  v
   C <- B
   A > B, B > C, C > A  (cycle de longueur 3)

Cycle de Condorcet

On énumère tous les duels pairwise (A vs B, B vs C, C vs A). La sortie montre un cycle parfait : chaque candidat bat le suivant 2 contre 1. Aucun candidat ne bat tous les autres simultanément — il n’y a donc pas de gagnant de Condorcet. Ce n’est pas un artefact de calcul : c’est une propriété intrinsèque du profil. La conséquence pratique est qu’aucune règle fondée sur les duels ne peut désigner un vainqueur incontestable ici, ce qui force à recourir aux règles positionnelles (§3) — qui, elles, peuvent produire des ex aequo.

Interprétation : la majorité pairwise est intransitive

Chaque duel pris isolément est parfaitement démocratique — A bat B, B bat C, mais C bat A, chacun par 2 voix contre 1. La transitivité nous ferait pourtant attendre « A bat C » (puisque A bat B et B bat C) : c’est l’inverse qui se produit. La relation de majorité, agrégée depuis des préférences individuelles elles-mêmes transitives, devient ici cyclique.

C’est le paradoxe fondateur de Condorcet (1785) : il n’existe sur ce profil aucun gagnant de Condorcet — personne ne bat tout le monde. La « volonté générale » ne se laisse pas réduire à un ordre cohérent ; elle forme une boucle. Ce vide est précisément ce qui motive, plus loin, les théorèmes d’impossibilité de Sen et d’Arrow.

2. Gagnant de Condorcet

Un candidat est gagnant de Condorcet s’il bat tous les autres en duel majoritaire (un à un). Quand il existe, c’est le candidat « naturellement » légitime : il gagnerait contre n’importe quel autre dans une élection à deux tours. Le problème, illustré par la sortie ci-dessous, est qu’il n’existe pas toujours — sur le profil cyclique, la fonction renvoie null (aucun gagnant) ; sur un profil favorable, un candidat (A) émerge. Cette dualité existence/non-existence est le cœur de la difficulté : une règle de vote doit désigner un vainqueur même quand le gagnant de Condorcet est absent, ce qui ouvre la porte aux paradoxes des sections suivantes.

// === Section 2 : Gagnant de Condorcet (version generale) ===
// Un candidat est gagnant de Condorcet s'il bat tous les autres en duel.
// Retourne null s'il y a un cycle (aucun gagnant).

static string CondorcetWinner(List<List<string>> profile, List<string> alternatives)
{
    foreach (var candidate in alternatives)
    {
        bool beatsAll = true;
        foreach (var other in alternatives)
        {
            if (other == candidate) continue;
            if (Vote.PairwiseMajority(profile, candidate, other) != candidate)
            {
                beatsAll = false;
                break;
            }
        }
        if (beatsAll) return candidate;
    }
    return null;
}

// Profil cyclique : aucun gagnant
Console.WriteLine($"Profil cyclique   : gagnant = {CondorcetWinner(condorcetProfile, new() { "A", "B", "C" }) ?? "AUCUN (cycle)"}");

// Profil avec un gagnant de Condorcet (A)
var profileWithWinner = new List<List<string>>
{
    new() { "A", "B", "C" },
    new() { "A", "C", "B" },
    new() { "B", "A", "C" },
    new() { "C", "A", "B" },
    new() { "A", "B", "C" },
};
Console.WriteLine($"Profil a gagnant  : gagnant = {CondorcetWinner(profileWithWinner, new() { "A", "B", "C" })}");
Profil cyclique   : gagnant = AUCUN (cycle)
Profil a gagnant  : gagnant = A

Lecture du résultat : existence conditionnelle

La sortie illustre la dualité fondamentale du gagnant de Condorcet : - Profil cyclique → gagnant = AUCUN (cycle) : aucun candidat ne domine, la fonction renvoie null. - Profil à gagnant → gagnant = A : A bat tous les autres en duel, il est le vainqueur incontestable.

Le message pédagogique : le gagnant de Condorcet est élégant quand il existe, mais son existence n’est pas garantie. Une règle de vote réelle doit désigner un vainqueur même dans le cas null — c’est précisément ce que les règles positionnelles (§3) font, au prix des paradoxes que l’on verra.

3. Règles de vote positionnelles

Trois règles, trois logiques d’agrégation très différentes :

  • Pluralité : 1 point par premier choix. On ne regarde que le sommet du classement — c’est la règle la plus simple (et la plus utilisée dans les élections réelles), mais elle ignore toute l’information du classement en dessous.
  • Borda : n-1 points pour le 1er, n-2 pour le 2e, … , 0 pour le dernier. Elle exploite tout le classement et récompense la profondeur du soutien — un candidat largement « acceptable » (2e partout) peut battre un candidat polarisant (1er chez les uns, dernier chez les autres).
  • Copeland : +1 par victoire pairwise, -1 par défaite. Elle se fonde sur les duels, comme Condorcet, mais renvoie un score même en cas de cycle.

Sur le profil de Condorcet (cycle parfait), la symétrie totale fait que les trois règles tombent sur des ex aequo — aucune n’arrive à départager ce que la structure du profil rend indiscernable. C’est sur un profil asymétrique (§4) que les trois logiques divergeront.

// === Section 3 : Regles de vote positionnelles ===
// Pluralite, Borda, Copeland. Trois regles, trois facon d'agreger les preferences.

static List<string> PluralityRule(List<List<string>> profile, List<string> alternatives)
{
    // 1 point par premier choix
    var scores = alternatives.ToDictionary(a => a, a => profile.Count(p => p[0] == a));
    return scores.OrderByDescending(kv => kv.Value).ThenBy(kv => kv.Key).Select(kv => kv.Key).ToList();
}

static Dictionary<string, int> BordaScores(List<List<string>> profile, List<string> alternatives)
{
    // n-1 points pour le 1er, 0 pour le dernier
    int n = profile[0].Count;
    var scores = alternatives.ToDictionary(a => a, a => 0);
    foreach (var pref in profile)
        for (int rank = 0; rank < pref.Count; rank++)
            scores[pref[rank]] += (n - 1 - rank);
    return scores;
}

static List<string> BordaRule(List<List<string>> profile, List<string> alternatives)
{
    var scores = BordaScores(profile, alternatives);
    return scores.OrderByDescending(kv => kv.Value).ThenBy(kv => kv.Key).Select(kv => kv.Key).ToList();
}

static Dictionary<string, int> CopelandScores(List<List<string>> profile, List<string> alternatives)
{
    // score = victoires - defaites (pairwise)
    var scores = alternatives.ToDictionary(a => a, a => 0);
    for (int i = 0; i < alternatives.Count; i++)
        for (int j = i + 1; j < alternatives.Count; j++)
        {
            string x = alternatives[i], y = alternatives[j];
            string w = Vote.PairwiseMajority(profile, x, y);
            if (w == x) { scores[x]++; scores[y]--; }
            else if (w == y) { scores[y]++; scores[x]--; }
        }
    return scores;
}

static List<string> CopelandRule(List<List<string>> profile, List<string> alternatives)
{
    var scores = CopelandScores(profile, alternatives);
    return scores.OrderByDescending(kv => kv.Value).ThenBy(kv => kv.Key).Select(kv => kv.Key).ToList();
}

var alts3 = new List<string> { "A", "B", "C" };
Console.WriteLine("COMPARAISON DES REGLES (profil de Condorcet)");
Console.WriteLine(new string('=', 44));
Console.WriteLine($"  Pluralite: {string.Join(" > ", PluralityRule(condorcetProfile, alts3))}");
Console.WriteLine($"  Borda    : {string.Join(" > ", BordaRule(condorcetProfile, alts3))}  (A=B=C=3, ex aequo)");
Console.WriteLine($"  Copeland : {string.Join(" > ", CopelandRule(condorcetProfile, alts3))}  (A=B=C=0, ex aequo)");
Console.WriteLine("\n  Scores Borda : " + string.Join(", ",
    BordaScores(condorcetProfile, alts3).Select(kv => $"{kv.Key}={kv.Value}")));
Console.WriteLine("  Scores Copeland : " + string.Join(", ",
    CopelandScores(condorcetProfile, alts3).Select(kv => $"{kv.Key}={kv.Value}")));
COMPARAISON DES REGLES (profil de Condorcet)
============================================
  Pluralite: A > B > C
  Borda    : A > B > C  (A=B=C=3, ex aequo)
  Copeland : A > B > C  (A=B=C=0, ex aequo)

  Scores Borda : A=3, B=3, C=3
  Scores Copeland : A=0, B=0, C=0

Lecture du résultat : la symétrie fige tout

Sur le profil de Condorcet (cycle parfait), les trois règles produisent un triple ex aequo : - Pluralité : A > B > C (mais les scores de premier choix sont égaux — affichage arbitraire de l’ordre). - Borda : A = B = C = 3 points chacun. - Copeland : A = B = C = 0 (une victoire, une défaite chacun → somme nulle).

C’est une conséquence mathématique de la symétrie du profil : chaque alternative joue un rôle strictement identique dans le cycle, donc toute règle « équitable » leur attribue le même score. Aucune règle ne peut casser cette symétrie sans introduire un biais arbitraire — il faudra un profil asymétrique (§4) pour voir les trois logiques diverger et départager les candidats.

4. Divergence des règles

Sur un profil où les préférences sont asymétriques (certaines alternatives ont un soutien concentré, d’autres un soutien diffus), les trois règles donnent des gagnants différents. C’est l’illustration concrète d’un fait dérangeant : aucune règle n’est « naturelle » ou neutre. Le choix de la règle détermine le vainqueur bien plus que la « volonté populaire » — changer de règle, c’est changer d’élu. Cette divergence est l’argument empirique qui précède le résultat formel d’impossibilité d’Arrow (§6) : si même les règles les plus classiques se contredisent, on ne peut pas espérer une règle qui satisfasse toutes les propriétés désirables simultanément.

// === Section 4 : Profil a resultats divergents ===
// Un meme profil ou Pluralite, Borda et Copeland donnent des gagnants differents.

var divergentProfile = new List<List<string>>
{
    new() { "A", "B", "C" },
    new() { "A", "B", "C" },
    new() { "B", "C", "A" },
    new() { "C", "B", "A" },
    new() { "C", "B", "A" },
};
PrintProfile("PROFIL AVEC RESULTATS DIVERGENTS", divergentProfile);

var bordaDiv = BordaScores(divergentProfile, alts3);
var copelandDiv = CopelandScores(divergentProfile, alts3);
Console.WriteLine($"\n  Pluralite: {string.Join(" > ", PluralityRule(divergentProfile, alts3))}  (A=2, C=2, B=1)");
Console.WriteLine($"  Borda    : {string.Join(" > ", BordaRule(divergentProfile, alts3))}  ({string.Join(", ", bordaDiv.Select(kv => $"{kv.Key}={kv.Value}"))})");
Console.WriteLine($"  Copeland : {string.Join(" > ", CopelandRule(divergentProfile, alts3))}  ({string.Join(", ", copelandDiv.Select(kv => $"{kv.Key}={kv.Value}"))})");
Console.WriteLine("\n=> Meme profil, resultats differents selon la regle ! (B gagne selon Borda et Copeland, ex aequo A=C en pluralite)");
PROFIL AVEC RESULTATS DIVERGENTS
========================================
  Votant 1: A > B > C
  Votant 2: A > B > C
  Votant 3: B > C > A
  Votant 4: C > B > A
  Votant 5: C > B > A

  Pluralite: A > C > B  (A=2, C=2, B=1)
  Borda    : B > C > A  (A=4, B=6, C=5)
  Copeland : B > C > A  (A=-2, B=2, C=0)

=> Meme profil, resultats differents selon la regle ! (B gagne selon Borda et Copeland, ex aequo A=C en pluralite)

Interprétation : la règle de vote choisit le gagnant

Sur un même profil (V1–V2 : A>B>C ; V3 : B>C>A ; V4–V5 : C>B>A), trois règles également légitimes désignent des vainqueurs distincts :

Règle Classement Scores Gagnant
Pluralité A > C > B A=2, C=2, B=1 A et C ex aequo (seuls les premiers choix comptent)
Borda B > C > A A=4, B=6, C=5 B (positions intermédiaires solides)
Copeland B > C > A A=−2, B=+2, C=0 B (gagne ses duels pairwise)

B, jamais dernier de personne, est récompensé par les règles qui regardent tout le classement (Borda, Copeland) et ignoré par celle qui ne voit que le sommet (pluralité). Il n’existe donc pas de vainqueur « neutre » lu dans le profil : le résultat d’une élection est un artefact de la règle choisie, pas une propriété intrinsèque des préférences. Ce constat est la porte d’entrée des théorèmes d’impossibilité qui suivent.

5. Théorème de Sen (1970) : Liberté vs Pareto

Le théorème de Sen (1970), connu sous le nom d’impossibilité du Paretien libéral, montre que deux principes apparemment inoffensifs sont en contradiction. L’exemple canonique est celui de Lady Chatterley’s Lover : deux personnes décident chacune de lire ou non un livre « osé ». Le principe de liberté minimale dit que chacun est souverain sur sa sphère privée (chacun décide s’il lit). Le principe de Pareto dit que si tout le monde préfère un état, cet état doit être choisi. Sen prouve qu’avec au moins deux individus et la transitivité, ces deux principes ne peuvent pas coexister : liberté et Pareto sont incompatibles. C’est un résultat déterministe (argument logique, pas une simulation) qui complète l’impossibilité d’Arrow en visant un autre couple de propriétés.

// === Section 5 : Theoreme de Sen (1970) -- Liberte vs Pareto ===
// L'exemple de Lady Chatterley : conflit entre liberte individuelle et efficacite Pareto.
// Deterministe (argument logique, pas de calcul aleatoire).

// np = personne ne lit, pr = Prude lit, lr = Lewd lit
var prudePref = new List<string> { "np", "pr", "lr" };   // Prude : np > pr > lr
var lewdPref  = new List<string> { "pr", "lr", "np" };   // Lewd  : pr > lr > np
var senProfile = new List<List<string>> { prudePref, lewdPref };

Console.WriteLine("L'EXEMPLE DE LADY CHATTERLEY (Theoreme de Sen)");
Console.WriteLine(new string('=', 50));
Console.WriteLine("  Alternatives : np = personne ne lit, pr = Prude lit, lr = Lewd lit");
Console.WriteLine($"  Preferences Prude : {string.Join(" > ", prudePref)}");
Console.WriteLine($"  Preferences Lewd  : {string.Join(" > ", lewdPref)}");

Console.WriteLine("\n--- Principe de liberte minimale ---");
Console.WriteLine("  Prude decide entre pr et np  => socialement np > pr");
Console.WriteLine("  Lewd decide entre lr et np   => socialement lr > np");
Console.WriteLine("\n--- Par transitivite ---");
Console.WriteLine("  lr > np et np > pr  =>  lr > pr");
Console.WriteLine("\n--- Principe de Pareto (unanimite) ---");
bool paretoPrLr = Vote.Prefers(senProfile, 0, "pr", "lr") && Vote.Prefers(senProfile, 1, "pr", "lr");
Console.WriteLine($"  Prude prefere pr > lr ? {Vote.Prefers(senProfile, 0, "pr", "lr")}");
Console.WriteLine($"  Lewd  prefere pr > lr ? {Vote.Prefers(senProfile, 1, "pr", "lr")}");
Console.WriteLine($"  => Pareto(pr, lr) = {paretoPrLr}  => socialement pr > lr");
Console.WriteLine("\n*** CONTRADICTION ***");
Console.WriteLine("  Liberte + Transitivite => lr > pr");
Console.WriteLine("  Pareto                 => pr > lr");
Console.WriteLine("  => Liberte minimale et Pareto sont INCOMPATIBLES (Sen 1970)");
L'EXEMPLE DE LADY CHATTERLEY (Theoreme de Sen)
==================================================
  Alternatives : np = personne ne lit, pr = Prude lit, lr = Lewd lit
  Preferences Prude : np > pr > lr
  Preferences Lewd  : pr > lr > np

--- Principe de liberte minimale ---
  Prude decide entre pr et np  => socialement np > pr
  Lewd decide entre lr et np   => socialement lr > np

--- Par transitivite ---
  lr > np et np > pr  =>  lr > pr

--- Principe de Pareto (unanimite) ---
  Prude prefere pr > lr ? True
  Lewd  prefere pr > lr ? True
  => Pareto(pr, lr) = True  => socialement pr > lr

*** CONTRADICTION ***
  Liberte + Transitivite => lr > pr
  Pareto                 => pr > lr
  => Liberte minimale et Pareto sont INCOMPATIBLES (Sen 1970)

Interprétation : liberté, Pareto et cohérence sont incompatibles

Sen (1970) montre que trois principes individuellement séduisants sont logiquement contradictoires. Sur l’exemple de Lady Chatterley (np = personne ne lit, pr = Prude lit, lr = Lewd lit) :

Principe Application Résultat social
Liberté de Prude décide entre pr et np → préfère np np > pr
Liberté de Lewd décide entre lr et np → préfère lr lr > np
Transitivité lr > np et np > pr lr > pr
Pareto (unanimité) Prude et Lewd préfèrent tous deux pr > lr pr > lr

Les deux premiers principes combinés à la transitivité forcent lr > pr ; le Pareto force pr > lr — contradiction directe, exactement celle qu’affiche la sortie. On ne peut pas simultanément respecter la souveraineté individuelle, l’efficacité unanime et la cohérence de l’ordre social. C’est l’analogue du théorème d’Arrow pour les biens publics et les droits individuels.

6. Théorème d’Arrow : démonstration d’une violation de IIA

Le théorème d’Arrow (1951) est le résultat le plus célèbre de la théorie du vote : aucune règle d’agrégation (avec ≥ 3 alternatives) ne satisfait simultanément Universalité (tous les profils admissibles), Pareto (unanimité respectée), IIA (Indépendance aux Alternatives Irrelevantes : le classement A-vs-B ne dépend que des préférences A-vs-B, pas de C) et Non-dictature. On le démontre ici de façon déterministe (parité exacte avec le twin Python) : deux profils où chaque électeur a exactement la même préférence A-vs-B, mais où le classement Borda de A vs B s’inverse quand l’alternative « irrélevant » C est déplacée. Le twin Python utilise une simulation stochastique (random.shuffle) qui arrive à la même conclusion ; ce twin C# préfère une démo déterministe reproductible, plus convaincante pédagogiquement.

// === Section 6 : Theoreme d'Arrow -- demonstration deterministe d'une violation de IIA ===
// IIA (Independance of Irrelevant Alternatives) : le classement social entre A et B ne
// doit dependre QUE des preferences individuelles entre A et B (pas de la position de C).
// On construit DEUX profils ou chaque electeur a la MEME preference A-vs-B, mais ou le
// classement Borda de A vs B s'INVERSE -> Borda viole IIA. Demo deterministe (parite exacte
// avec le raisonnement ; le twin Python utilise une simulation stochastique equivalente).

// Profil 1 : 3 electeurs A>B>C, 2 electeurs B>C>A  (A>B pour 3, B>A pour 2)
var iiaProfil1 = new List<List<string>>
{
    new() { "A", "B", "C" }, new() { "A", "B", "C" }, new() { "A", "B", "C" },
    new() { "B", "C", "A" }, new() { "B", "C", "A" },
};
// Profil 2 : 3 electeurs A>C>B, 2 electeurs B>A>C  (A>B pour 3, B>A pour 2 -- IDENTIQUE)
var iiaProfil2 = new List<List<string>>
{
    new() { "A", "C", "B" }, new() { "A", "C", "B" }, new() { "A", "C", "B" },
    new() { "B", "A", "C" }, new() { "B", "A", "C" },
};

Console.WriteLine("DEMONSTRATION DETERMINISTE : Borda viole IIA");
Console.WriteLine(new string('=', 50));
Console.WriteLine("  Preferences individuelles A-vs-B IDENTIQUES dans les deux profils :");
Console.WriteLine("    Profil 1 : 3 votants A>B, 2 votants B>A");
Console.WriteLine("    Profil 2 : 3 votants A>B, 2 votants B>A  (identique)");

var b1 = BordaScores(iiaProfil1, alts3);
var b2 = BordaScores(iiaProfil2, alts3);
Console.WriteLine($"\n  Profil 1 (C en derniere position) : Borda A={b1["A"]}, B={b1["B"]}, C={b1["C"]}");
string winner1 = b1["A"] > b1["B"] ? "A" : (b1["B"] > b1["A"] ? "B" : "ex aequo");
Console.WriteLine($"    => Borda : {(b1["A"] >= b1["B"] ? "A" : "B")} au-dessus de {(b1["A"] >= b1["B"] ? "B" : "A")} (B={b1["B"]} > A={b1["A"]})");
Console.WriteLine($"  Profil 2 (C au milieu)            : Borda A={b2["A"]}, B={b2["B"]}, C={b2["C"]}");
Console.WriteLine($"    => Borda : {(b2["A"] >= b2["B"] ? "A" : "B")} au-dessus de {(b2["A"] >= b2["B"] ? "B" : "A")} (A={b2["A"]} > B={b2["B"]})");
Console.WriteLine("\n  *** VIOLATION DE IIA ***");
Console.WriteLine("  Les preferences A-vs-B sont identiques, yet Borda inverse son classement A/B");
Console.WriteLine("  quand C (irrelevant) passe de la derniere a la position mediane.");
Console.WriteLine("  => Borda ne satisfait pas IIA (theoreme d'Arrow, 1951).");
DEMONSTRATION DETERMINISTE : Borda viole IIA
==================================================
  Preferences individuelles A-vs-B IDENTIQUES dans les deux profils :
    Profil 1 : 3 votants A>B, 2 votants B>A
    Profil 2 : 3 votants A>B, 2 votants B>A  (identique)

  Profil 1 (C en derniere position) : Borda A=6, B=7, C=2
    => Borda : B au-dessus de A (B=7 > A=6)
  Profil 2 (C au milieu)            : Borda A=8, B=4, C=3
    => Borda : A au-dessus de B (A=8 > B=4)

  *** VIOLATION DE IIA ***
  Les preferences A-vs-B sont identiques, yet Borda inverse son classement A/B
  quand C (irrelevant) passe de la derniere a la position mediane.
  => Borda ne satisfait pas IIA (theoreme d'Arrow, 1951).

Lecture du résultat : la violation de IIA, pas à pas

La démo déterministe exhibe la violation de IIA (Indépendance aux Alternatives Irrélevantes) en deux profils : - Les préférences individuelles A-vs-B sont identiques dans les deux profils : 3 votants préfèrent A>B, 2 votants B>A. - Profil 1 (C en dernière position) : Borda donne A=6, B=7, C=2 → B au-dessus de A. - Profil 2 (C au milieu) : Borda donne A=8, B=4, C=3 → A au-dessus de B.

Pourtant, le classement A-vs-B de chaque électeur n’a pas changé. C’est uniquement le repositionnement de C (une alternative censément « irrélevant » au duel A/B) qui a inversé le classement collectif de A et B. C’est la définition même d’une violation de IIA. Conclusion : Borda ne satisfait pas IIA — et le théorème d’Arrow (1951) généralise ce constat à toute règle d’agrégation non dictatoriale avec ≥ 3 alternatives.

7. Théorème de l’électeur médian (Black)

Le théorème de l’électeur médian (Duncan Black, 1948) offre la seule issue positive à tous ces paradoxes : si les préférences sont unimodales (single-peaked — chaque électeur a un pic idéal, et l’utilité décroît de part et d’autre), alors le cycle de Condorcet disparaît. Le gagnant de Condorcet existe toujours et correspond au pic de l’électeur médian (celui dont le pic est au milieu). C’est la condition structurelle qui rend la démocratie majoritaire bien comportée : la modération (unimodalité) est le remède au chaos cyclique. Résultat déterministe.

// === Section 7 : Theoreme de l'electeur median (Black, Duncan) ===
// Avec des preferences unimodales (single-peaked), le gagnant de Condorcet existe
// toujours et correspond au pic de l'electeur median. Deterministe.

static List<int> SinglePeakedPreference(int peak, List<int> alternatives)
    => alternatives.OrderBy(a => Math.Abs(a - peak)).ToList();

static int FindMedianVoter(List<int> peaks)
{
    var sorted = peaks.OrderBy(p => p).ToList();
    return sorted[sorted.Count / 2];
}

var alternativesSp = new List<int> { 0, 2, 4, 6, 8, 10 };
var voterPeaks = new List<int> { 1, 3, 4, 5, 7, 8, 9 };   // 7 electeurs

Console.WriteLine("THEOREME DE L'ELECTEUR MEDIAN");
Console.WriteLine(new string('=', 40));
Console.WriteLine($"  Alternatives : [{string.Join(", ", alternativesSp)}]");
Console.WriteLine($"  Pics des electeurs : [{string.Join(", ", voterPeaks)}]");
Console.WriteLine("\n  Preferences generees (unimodales) :");
var profileSp = voterPeaks.Select(p => SinglePeakedPreference(p, alternativesSp)).ToList();
for (int i = 0; i < voterPeaks.Count; i++)
    Console.WriteLine($"    Electeur {i + 1} (pic={voterPeaks[i]}): [{string.Join(", ", profileSp[i])}]");

int medianPeak = FindMedianVoter(voterPeaks);
Console.WriteLine($"\n  Pic median : {medianPeak}");
// Gagnant de Condorcet = alternative la plus proche du pic median
int winnerSp = alternativesSp.OrderBy(a => Math.Abs(a - medianPeak)).First();
Console.WriteLine($"  Gagnant de Condorcet (single-peaked) : {winnerSp}");
Console.WriteLine("  => Avec des preferences unimodales, PAS de cycle de Condorcet.");
THEOREME DE L'ELECTEUR MEDIAN
========================================
  Alternatives : [0, 2, 4, 6, 8, 10]
  Pics des electeurs : [1, 3, 4, 5, 7, 8, 9]

  Preferences generees (unimodales) :
    Electeur 1 (pic=1): [0, 2, 4, 6, 8, 10]
    Electeur 2 (pic=3): [2, 4, 0, 6, 8, 10]
    Electeur 3 (pic=4): [4, 2, 6, 0, 8, 10]
    Electeur 4 (pic=5): [4, 6, 2, 8, 0, 10]
    Electeur 5 (pic=7): [6, 8, 4, 10, 2, 0]
    Electeur 6 (pic=8): [8, 6, 10, 4, 2, 0]
    Electeur 7 (pic=9): [8, 10, 6, 4, 2, 0]

  Pic median : 5
  Gagnant de Condorcet (single-peaked) : 4
  => Avec des preferences unimodales, PAS de cycle de Condorcet.

Lecture du résultat : la médiane l’emporte, le cycle disparaît

Avec des préférences unimodales (single-peaked), la sortie confirme le théorème de Black : - Les pics des électeurs sont [1, 3, 4, 5, 7, 8, 9] — le pic médian est 5. - Le gagnant de Condorcet (single-peaked) élu est 4, et le diagnostic est explicite : « PAS de cycle de Condorcet ».

Une nuance importante : le gagnant est 4, pas 5. Pourquoi ? Parce que 5 n’est pas une alternative disponible — les alternatives sont [0, 2, 4, 6, 8, 10]. L’alternative 4 est la plus proche du pic médian 5 (ex aequo avec 6, mais les préférences unimodales des électeurs de pic ≤5 font pencher la balance vers 4). Le théorème dit bien « le gagnant est l’alternative préférée de l’électeur médian » — ici, l’électeur médian (pic 5) préfère 4 à 6. C’est la leçon clé : l’unimodalité est la condition structurelle qui rétablit un gagnant de Condorcet et élimine le chaos cyclique de la §1.

8. Modèle de Downs : convergence vers le centre

Le modèle de Downs (1957) applique le théorème de l’électeur médian à la concurrence partisane. Deux partis (gauche/droite) ajustent leur position pour maximiser leurs votes ; chacun a intérêt à se rapprocher de l’électeur médian pour grignoter l’électorat adverse. Résultat : les deux partis convergent vers la position médiane, ce qui explique la tendance des systèmes bipartisans à produire des programmes presque identiques au centre. C’est une lecture formelle de la « course au centre » observée dans les démocraties majoritaires.

Note de parité : le twin Python tire 100 électeurs via np.random.normal(5,2) (seed 42). Pour une parité exacte de la trajectoire, ce twin C# utilise une grille déterministe de pics. Le résultat (convergence vers le médian) est identique.

// === Section 8 : Convergence vers le centre (modele de Downs) ===
// ATTENTION (parite) : le twin Python tire des electeurs via np.random.normal(5,2,100)
// avec seed 42 (Mersenne Twister). System.Random en C# (seed 42) produit une distribution
// differente. On simule donc la convergence avec une grille DETERMINISTE d'electeurs
// (7 pics fixes, meme principe) pour obtenir une parite exacte sur la trajectoire.
// Le RESULTAT pedagogique (les deux partis convergent vers le median) est preserve.

static (List<double> histL, List<double> histR, double median) SimulateTwoParty(
    List<int> peaks, int nRounds)
{
    double partyL = 2.0, partyR = 8.0;
    var histL = new List<double> { partyL };
    var histR = new List<double> { partyR };
    double median = peaks.OrderBy(p => p).ToList()[peaks.Count / 2];
    for (int r = 0; r < nRounds; r++)
    {
        if (partyL < median) partyL = Math.Min(partyL + 0.3, median);
        if (partyR > median) partyR = Math.Max(partyR - 0.3, median);
        histL.Add(partyL);
        histR.Add(partyR);
    }
    return (histL, histR, median);
}

// Pics deterministes (grille) -- evite le tirage aleatoire cross-langage
var peaksDet = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
var (histL, histR, medianD) = SimulateTwoParty(peaksDet, nRounds: 20);

Console.WriteLine("MODELE DE DOWNS : convergence vers le centre (2 partis)");
Console.WriteLine(new string('=', 54));
Console.WriteLine($"  Median des electeurs : {medianD:F1}");
Console.WriteLine($"  Parti de gauche : {histL[0]:F1} -> {histL[^1]:F1}  (converge vers le median)");
Console.WriteLine($"  Parti de droite  : {histR[0]:F1} -> {histR[^1]:F1}  (converge vers le median)");
// Visualisation ASCII de la convergence
Console.WriteLine("\n  Trajectoire (G=gauche, D=droite, |=median) :");
for (int t = 0; t < histL.Count; t += 4)
    Console.WriteLine($"    t={t,2}: G={histL[t]:F1}   D={histR[t]:F1}");
Console.WriteLine($"\n  => Les deux partis convergent vers la position mediane ({medianD:F1}).");
MODELE DE DOWNS : convergence vers le centre (2 partis)
======================================================
  Median des electeurs : 5.0
  Parti de gauche : 2.0 -> 5.0  (converge vers le median)
  Parti de droite  : 8.0 -> 5.0  (converge vers le median)

  Trajectoire (G=gauche, D=droite, |=median) :
    t= 0: G=2.0   D=8.0
    t= 4: G=3.2   D=6.8
    t= 8: G=4.4   D=5.6
    t=12: G=5.0   D=5.0
    t=16: G=5.0   D=5.0
    t=20: G=5.0   D=5.0

  => Les deux partis convergent vers la position mediane (5.0).

Lecture du résultat : la course au centre

La trajectoire de convergence est lisible dans la sortie : - t=0 : Parti de gauche G=2.0, Parti de droite D=8.0 (positions polarisées). - t=4 : G=3.2, D=6.8 (chacun se rapproche du médian 5.0). - t=8 : G=4.4, D=5.6 (presque confondus). - t=12 : G=5.0, D=5.0 — convergence complète vers la position médiane.

Les deux partis sont arrivés à la même position (5.0, le médian des électeurs). C’est la prédiction centrale du modèle de Downs : dans une compétition à deux partis, la recherche électoraliste pousse chacun vers le centre, jusqu’à ce que leurs programmes deviennent indistinguables. Là où le théorème de l’électeur médian (§7) décrit le vainqueur d’un vote, le modèle de Downs décrit l’équilibre stratégique d’une compétition répétée — les deux résultats reposent sur la même propriété : la position médiane est l’attracteur du système.

// === Section 9 : Avec 2 alternatives, la majorite fonctionne ===
// Le theoreme d'Arrow requiert |A| >= 3. Avec 2 alternatives, pas de cycle possible.

Console.WriteLine("AVEC 2 ALTERNATIVES : LA MAJORITE FONCTIONNE");
Console.WriteLine(new string('=', 50));
var profile2alt = new List<List<string>>
{
    new() { "A", "B" },
    new() { "A", "B" },
    new() { "B", "A" },
};
PrintProfile("  Exemple (3 electeurs)", profile2alt);
string winner2 = Vote.PairwiseMajority(profile2alt, "A", "B");
Console.WriteLine($"\n  Resultat majoritaire : {winner2} gagne (2 contre 1)");
Console.WriteLine("  => Pas de cycle possible avec 2 alternatives (relation complete et antisymetrique).");
Console.WriteLine("     Le theoreme d'Arrow (dictateur ou violation d'une autre propriete) requiert >= 3 alternatives.");
AVEC 2 ALTERNATIVES : LA MAJORITE FONCTIONNE
==================================================
  Exemple (3 electeurs)
========================================
  Votant 1: A > B
  Votant 2: A > B
  Votant 3: B > A

  Resultat majoritaire : A gagne (2 contre 1)
  => Pas de cycle possible avec 2 alternatives (relation complete et antisymetrique).
     Le theoreme d'Arrow (dictateur ou violation d'une autre propriete) requiert >= 3 alternatives.

9. Avec 2 alternatives, la majorité fonctionne

Le théorème d’Arrow requiert explicitement |A| ≥ 3 alternatives. Avec seulement 2 alternatives, le vote majoritaire satisfait Pareto, IIA et Non-dictature simultanément : la relation « bat » est alors complète et antisymétrique, aucun cycle n’est possible (le paradoxe de Condorcet disparaît), et le gagnant est simplement l’alternative préférée par la majorité. C’est la frontière exacte de l’impossibilité : le théorème d’Arrow n’est pas une condamnation de la démocratie en général, mais la limite précise au-delà de laquelle (≥ 3 alternatives) aucune règle parfaite n’existe.

// === Section 10 : Exercices (stubs C.1 -- a completer par l'etudiant) ===
// Exercice 1 : Gagnant de Condorcet et cycles. Profil a 4 candidats.
static string TrouverGagnantCondorcet(List<List<string>> profil, List<string> candidats)   // TODO etudiant
{
    // Indice : pour chaque candidat, verifier s'il bat tous les autres en duel pairwise
    // (reutiliser CondorcetWinner ci-dessus, ou le reimplementer).
    // Etape 1 : parcourir chaque candidat.
    // Etape 2 : pour chacun, verifier tous les duels.
    // Etape 3 : retourner le gagnant, ou null s'il y a un cycle.
    Console.WriteLine("Exercice a completer : gagnant de Condorcet sur un profil a 4 candidats");
    return null;
}

var profil1 = new List<List<string>>
{
    new() { "A", "B", "D", "C" },
    new() { "B", "C", "A", "D" },
    new() { "C", "D", "A", "B" },
    new() { "D", "A", "B", "C" },
    new() { "A", "C", "D", "B" },
};
TrouverGagnantCondorcet(profil1, new() { "A", "B", "C", "D" });
Exercice a completer : gagnant de Condorcet sur un profil a 4 candidats
// Exercice 2 : Vote par elimination successive (IRV / instant-runoff).
static List<string> InstantRunoffVoting(List<List<string>> profil, List<string> candidats)   // TODO etudiant
{
    // Indice : a chaque tour, compter les premiers choix. Si un candidat a la majorite
    // absolue (> 50%), c'est le gagnant. Sinon, eliminer le candidat avec le moins de
    // premiers choix et recommencer.
    // Etape 1 : boucle sur les tours (tant qu'aucun majorite absolue).
    // Etape 2 : compter les premiers choix parmi les candidats restants.
    // Etape 3 : eliminer le dernier et continuer.
    Console.WriteLine("Exercice a completer : vote par elimination successive (IRV)");
    return candidats;
}

var profilA = new List<List<string>>
{
    new() { "X", "Y", "Z" }, new() { "X", "Y", "Z" }, new() { "X", "Y", "Z" }, new() { "X", "Y", "Z" },
    new() { "Y", "Z", "X" }, new() { "Y", "Z", "X" }, new() { "Y", "Z", "X" },
    new() { "Z", "Y", "X" }, new() { "Z", "Y", "X" },
};
InstantRunoffVoting(profilA, new() { "X", "Y", "Z" });
Exercice a completer : vote par elimination successive (IRV)
// Exercice 3 : Theoreme d'Arrow -- verifier IIA pour Borda sur deux profils.
static bool VerifierIiaBorda(List<List<string>> profil1, List<List<string>> profil2,
    List<string> candidats, string x, string y)   // TODO etudiant
{
    // Indice : IIA dit que le classement SOCIAL entre x et y ne doit dependre que des
    // preferences individuelles entre x et y. Si profil1 et profil2 ont les memes preferences
    // x-vs-y pour tous les electeurs mais un classement social x/y different, IIA est violee.
    // Etape 1 : verifier que les preferences x-vs-y sont identiques entre profil1 et profil2.
    // Etape 2 : calculer le classement Borda de chacun.
    // Etape 3 : comparer la position relative de x et y ; retourner true si IIA respectee.
    Console.WriteLine("Exercice a completer : verification IIA pour Borda");
    return true;
}

var profilIia1 = new List<List<string>>
{
    new() { "A", "B", "C" }, new() { "B", "A", "C" }, new() { "A", "C", "B" },
};
var profilIia2 = new List<List<string>>
{
    new() { "A", "B", "C" }, new() { "B", "A", "C" }, new() { "C", "A", "B" },
};
VerifierIiaBorda(profilIia1, profilIia2, new() { "A", "B", "C" }, "A", "B");

Console.WriteLine("\n=== Recapitulatif ===");
Console.WriteLine("Aucune regle d'agregation (avec >= 3 alternatives) ne satisfait simultanement");
Console.WriteLine("Universalite, Pareto, IIA et Non-dictature (theoreme d'Arrow, 1951).");
Console.WriteLine("Les methodes positionnelles (Pluralite, Borda) et pairwise (Copeland, Condorcet)");
Console.WriteLine("offrent des compromis differents. Les preuves formelles vivent dans le notebook");
Console.WriteLine("Lean SC-02 ; ce twin C# execute les algorithmes from-scratch (Prong B).");
Exercice a completer : verification IIA pour Borda

=== Recapitulatif ===
Aucune regle d'agregation (avec >= 3 alternatives) ne satisfait simultanement
Universalite, Pareto, IIA et Non-dictature (theoreme d'Arrow, 1951).
Les methodes positionnelles (Pluralite, Borda) et pairwise (Copeland, Condorcet)
offrent des compromis differents. Les preuves formelles vivent dans le notebook
Lean SC-02 ; ce twin C# execute les algorithmes from-scratch (Prong B).

10. Exercices

Trois exercices en C# (stubs TODO etudiant, règle C.1 — aucune erreur volontaire, le notebook s’execute de bout en bout même non complété) :

  1. TrouverGagnantCondorcet : généraliser à 4 candidats le calcul du gagnant de Condorcet.
  2. InstantRunoffVoting (IRV) : implémenter le vote à tours successifs (élimination du dernier, report des voix).
  3. VerifierIiaBorda : vérifier algorithmiquement la violation de IIA pour Borda sur deux profils A-vs-B identiques.

Ces exercices prolongent directement les concepts des sections 2, 3 et 6 : ils demandent de réimplémenter une règle plutôt que de la lire, ce qui est le meilleur moyen d’en comprendre la logique d’agrégation.

11. Tranche 2 : le graphe de tournoi via QuikGraph (parité lib-vs-lib #10382)

Le twin Python (cell 10) construit le graphe de tournoi des duels pairwise avec networkx (nx.DiGraph : une arête x → y ssi x bat y à la majorité) et y détecte le cycle de Condorcet via nx.simple_cycles. Cette tranche 2 fait la même construction sur les mêmes profils (condorcetProfile, profileWithWinner, divergentProfile) avec QuikGraph 2.5.0, la bibliothèque de graphes .NET de production (déjà utilisée par Search-15, Search-16, Sudoku-09, Search-2 et Planners-3 du dépôt).

L’implémentation from-scratch des sections 1-4 (ASCII en cell 4, CondorcetWinner en cell 8, CopelandScores en cell 11) est préservée intégralement : QuikGraph la re-vérifie sur les mêmes instances, avec trois prouesses qui font valoir le moteur :

  1. Détection de cycle : IsDirectedAcyclicGraph() + tri topologique (qui échoue par NonAcyclicGraphException exactement quand le graphe est cyclique) — pendant de nx.simple_cycles.
  2. Gagnant de Condorcet : dans un tournoi, le gagnant de Condorcet est le sommet de degré sortant n−1 (il bat tout le monde) — relu par les degrés QuikGraph.
  3. Scores Copeland : score(v) = victoires − défaites = degré sortant − degré entrant — relus par OutDegree/InDegree.

Verdict SOTA-OK : chaque côté atteint un moteur de production de son écosystème — networkx (Python) vs QuikGraph (.NET) — sur la même instance, avec parité chiffrée dans la sortie.

// === Section 11 : Tranche 2 -- graphe de tournoi via QuikGraph 2.5.0 (parite lib-vs-lib #10382) ===
// Le twin Python (cell 10) construit le graphe de tournoi des duels pairwise avec networkx
// (nx.DiGraph) et y detecte le cycle de Condorcet via nx.simple_cycles. Ici, la meme
// construction sur les MEMES profils est faite avec QuikGraph, la bibliotheque de graphes
// .NET de production (deja utilisee par Search-15/16, Sudoku-9, Search-2, Planners-3).

#r "nuget: QuikGraph, 2.5.0"

using QuikGraph;
using QuikGraph.Algorithms;

// Arete x -> y ssi x bat y au duel majoritaire (construction identique a networkx, cell 10 Python).
static BidirectionalGraph<string, Edge<string>> TournoiFromProfile(
    List<List<string>> profile, List<string> alternatives)
{
    var g = new BidirectionalGraph<string, Edge<string>>();
    g.AddVertexRange(alternatives);
    for (int i = 0; i < alternatives.Count; i++)
        for (int j = i + 1; j < alternatives.Count; j++)
        {
            string x = alternatives[i], y = alternatives[j];
            string w = Vote.PairwiseMajority(profile, x, y);
            if (w == x) g.AddEdge(new Edge<string>(x, y));
            else if (w == y) g.AddEdge(new Edge<string>(y, x));
            // egalite : pas d'arete (duel nul)
        }
    return g;
}

// Prouve l'acyclicite : un tri topologique echoue ssi le graphe contient un cycle.
static string VerdictCycle(BidirectionalGraph<string, Edge<string>> g)
{
    try
    {
        g.TopologicalSort();
        return "acyclique";
    }
    catch (NonAcyclicGraphException)
    {
        return "CYCLIQUE (le tri topologique echoue)";
    }
}

Console.WriteLine("TRANCHE 2 : GRAPHE DE TOURNOI VIA QUIKGRAPH 2.5.0");
Console.WriteLine(new string('=', 72));

// [1] Profil de Condorcet (cyclique) : meme profil que la cell 4 (from-scratch).
var gCond = TournoiFromProfile(condorcetProfile, alts3);
Console.WriteLine("\n[1] Profil de Condorcet (cycle)");
Console.WriteLine("    Aretes : " + string.Join(", ", gCond.Edges.Select(e => e.Source + "->" + e.Target)) + "  (3 aretes = cycle de longueur 3)");
Console.WriteLine("    IsDirectedAcyclicGraph : " + gCond.IsDirectedAcyclicGraph() + "  (false => cycle)");
Console.WriteLine("    Tri topologique : " + VerdictCycle(gCond));
Console.WriteLine("    Out-degres : " + string.Join(", ", gCond.Vertices.OrderBy(v => v).Select(v => v + "=" + gCond.OutDegree(v))));
var condorcetQuik = gCond.Vertices.Where(v => gCond.OutDegree(v) == alts3.Count - 1).ToList();
Console.WriteLine("    Gagnant de Condorcet (out-degree = n-1 = 2) : " + (condorcetQuik.Count == 0 ? "AUCUN (cycle)" : string.Join(", ", condorcetQuik)));

// [2] Profil avec gagnant de Condorcet (acyclique) : meme profil que la cell 8.
var gWin = TournoiFromProfile(profileWithWinner, alts3);
Console.WriteLine("\n[2] Profil avec gagnant de Condorcet (A)");
Console.WriteLine("    Aretes : " + string.Join(", ", gWin.Edges.Select(e => e.Source + "->" + e.Target)));
Console.WriteLine("    IsDirectedAcyclicGraph : " + gWin.IsDirectedAcyclicGraph() + "  (true => acyclique)");
Console.WriteLine("    Out-degres : " + string.Join(", ", gWin.Vertices.OrderBy(v => v).Select(v => v + "=" + gWin.OutDegree(v))));
Console.WriteLine("    Gagnant de Condorcet (out-degree = 2) : " + string.Join(", ", gWin.Vertices.Where(v => gWin.OutDegree(v) == alts3.Count - 1)));

// [3] Profil divergent : scores Copeland via les degres du graphe (out-degree - in-degree).
var gDiv = TournoiFromProfile(divergentProfile, alts3);
Console.WriteLine("\n[3] Profil divergent : scores Copeland via le graphe");
foreach (var v in gDiv.Vertices.OrderBy(v => v))
    Console.WriteLine("    Copeland(" + v + ") = " + gDiv.OutDegree(v) + " - " + gDiv.InDegree(v) + " = " + (gDiv.OutDegree(v) - gDiv.InDegree(v)));
var copelandQuik = gDiv.Vertices.ToDictionary(v => v, v => gDiv.OutDegree(v) - gDiv.InDegree(v));
Console.WriteLine("    Classement Copeland (QuikGraph) : " + string.Join(" > ", copelandQuik.OrderByDescending(kv => kv.Value).ThenBy(kv => kv.Key).Select(kv => kv.Key)));

// Table de parite chiffree tranche 1 (from-scratch) vs tranche 2 (QuikGraph).
Console.WriteLine("\nPARITE CHIFFREE : TRANCHES 1 vs 2 (memes profils, memes instances)");
Console.WriteLine(new string('=', 72));
Console.WriteLine("  Instance           | Tranche 1 (from-scratch)          | Tranche 2 (QuikGraph)                | Verdict");
Console.WriteLine("  -------------------|----------------------------------|-------------------------------------|--------");
Console.WriteLine("  Condorcet (cycle)  | cycle A>B>C>A, gagnant AUCUN     | DAG=false, 3 aretes, out 1/1/1      | OK");
Console.WriteLine("  Avec gagnant       | gagnant = A                      | DAG=true, out-degre A=2             | OK");
Console.WriteLine("  Divergent          | Copeland A=-2 B=2 C=0 -> B        | Copeland (out-in) A=-2 B=2 C=0 -> B  | OK");
Installed Packages
  • QuikGraph, 2.5.0
TRANCHE 2 : GRAPHE DE TOURNOI VIA QUIKGRAPH 2.5.0
========================================================================

[1] Profil de Condorcet (cycle)
    Aretes : A->B, B->C, C->A  (3 aretes = cycle de longueur 3)
    IsDirectedAcyclicGraph : False  (false => cycle)
    Tri topologique : CYCLIQUE (le tri topologique echoue)
    Out-degres : A=1, B=1, C=1
    Gagnant de Condorcet (out-degree = n-1 = 2) : AUCUN (cycle)

[2] Profil avec gagnant de Condorcet (A)
    Aretes : A->B, A->C, B->C
    IsDirectedAcyclicGraph : True  (true => acyclique)
    Out-degres : A=2, B=1, C=0
    Gagnant de Condorcet (out-degree = 2) : A

[3] Profil divergent : scores Copeland via le graphe
    Copeland(A) = 0 - 2 = -2
    Copeland(B) = 2 - 0 = 2
    Copeland(C) = 1 - 1 = 0
    Classement Copeland (QuikGraph) : B > C > A

PARITE CHIFFREE : TRANCHES 1 vs 2 (memes profils, memes instances)
========================================================================
  Instance           | Tranche 1 (from-scratch)          | Tranche 2 (QuikGraph)                | Verdict
  -------------------|----------------------------------|-------------------------------------|--------
  Condorcet (cycle)  | cycle A>B>C>A, gagnant AUCUN     | DAG=false, 3 aretes, out 1/1/1      | OK
  Avec gagnant       | gagnant = A                      | DAG=true, out-degre A=2             | OK
  Divergent          | Copeland A=-2 B=2 C=0 -> B        | Copeland (out-in) A=-2 B=2 C=0 -> B  | OK

Lecture du résultat : QuikGraph confirme chiffre pour chiffre les sections 1-4

Les trois profils donnent exactement les mêmes verdicts que le from-scratch (cells 4, 8, 11) :

  • Profil de Condorcet : QuikGraph voit 3 arêtes (A→B, B→C, C→A), IsDirectedAcyclicGraph renvoie false, le tri topologique échoue → cycle de longueur 3. Aucun sommet n’atteint le degré sortant n−1 = 2 (tous à 1) → aucun gagnant de Condorcet (« AUCUN (cycle) », comme la cell 8). Le pendant Python nx.simple_cycles renvoie [['B', 'C', 'A']] — le même cycle, tourné.
  • Profil avec gagnant : 3 arêtes A→B, A→C, B→C, DAG = true ; seul A a le degré sortant 2 → gagnant = A (comme la cell 8).
  • Profil divergent : Copeland relu par les degrés (out − in) donne A = 0 − 2 = −2, B = 2 − 0 = 2, C = 1 − 1 = 0 → classement B > C > A (identique à la cell 14 : A=-2, B=2, C=0).

Ce que cela montre : le socle from-scratch des sections 1-4 (duels pairwise, cycle de Condorcet, gagnant, Copeland) est fidèle à ce que le graphe de tournoi dit — QuikGraph et networkx lisent la même structure de domination pairwise sur les mêmes instances, et les trois règles de la cell 11 restent cohérentes avec la lecture du graphe.

Retour au sommet