Add François Durand's Super Condorcet Winner concept as a set.

The concept is from

DURAND, François. Why Instant-Runoff Voting Is So Resilient to Coalitional
Manipulation: Phase Transitions in the Perturbed Culture. In: Proc. of the
24th International Conference on Autonomous Agents and Multiagent Systems.
2025. p. 658-666. https://www.ifaamas.org/Proceedings/aamas2025/pdfs/p658.pdf

Author: kristomu

CMakeLists.txt

@@ -181,6 +181,7 @@ add_library(qe_singlewinner_methods
 	src/singlewinner/sets/mdd.cc
 	src/singlewinner/sets/mutual_majority.cc
 	src/singlewinner/sets/partition.cc
+	src/singlewinner/sets/scw.cc
 	src/singlewinner/sets/topological.cc
 	src/singlewinner/stats/cardinal.cc
 	src/singlewinner/stats/mode.cc

src/singlewinner/get_methods.cc

@@ -138,7 +138,9 @@ std::vector<std::shared_ptr<pairwise_method> > get_pairwise_sets() {
 	return pw_sets;
 }
 
-std::vector<std::shared_ptr<election_method> > get_sets() {
+std::vector<std::shared_ptr<election_method> > get_sets(
+	bool include_experimental) {
+
 	std::vector<std::shared_ptr<election_method> > sets;
 
 	for (std::shared_ptr<election_method> em_set: get_pairwise_sets()) {
@@ -148,6 +150,11 @@ std::vector<std::shared_ptr<election_method> > get_sets() {
 	sets.push_back(std::make_shared<mutual_majority_set>());
 	sets.push_back(std::make_shared<dmt_set>());
 	sets.push_back(std::make_shared<inner_burial_set>());
+	sets.push_back(std::make_shared<super_condorcet_set>());
+
+	if (include_experimental) {
+		sets.push_back(std::make_shared<idisqualif_set>());
+	}
 
 	return sets;
 }
@@ -165,7 +172,8 @@ std::vector<std::shared_ptr<election_method> > get_singlewinner_methods(
 
 	std::vector<std::shared_ptr<positional> > positional_methods =
 		get_positional_methods(truncate);
-	std::vector<std::shared_ptr<election_method> > sets = get_sets();
+	std::vector<std::shared_ptr<election_method> > sets = get_sets(
+			include_experimental);
 
 	// We have to do it in this clumsy manner because of possible bugs in
 	// handling methods with some candidates excluded.
@@ -230,6 +238,8 @@ std::vector<std::shared_ptr<election_method> > get_singlewinner_methods(
 
 	all_methods.push_back(std::make_shared<donated_contingent_vote>());
 
+	all_methods.push_back(std::make_shared<hash_random_cand>());
+
 	if (include_experimental) {
 
 		for (int p = 0; p <= CM_LAST; ++p) {

src/singlewinner/get_methods.h

@@ -11,7 +11,8 @@ std::vector<std::shared_ptr<positional> > get_positional_methods(
 	bool truncate);
 
 std::vector<std::shared_ptr<pairwise_method> > get_pairwise_sets();
-std::vector<std::shared_ptr<election_method> > get_sets();
+std::vector<std::shared_ptr<election_method> > get_sets(
+	bool include_experimental);
 
 // This function could stand being split into two or more: one for
 // comma and slash combinations, and one for loser elimination and

src/singlewinner/sets/all.h

@@ -15,6 +15,7 @@
 #include "mutual_majority.h"
 #include "partition.h"
 #include "topological.h"
+#include "scw.h"
 
 #include "debug/venzke_landau.h"
 

src/singlewinner/sets/scw.cc

@@ -0,0 +1,71 @@
+
+#include "singlewinner/dmt/resistant/subelections.h"
+#include "scw.h"
+
+#include <iostream>
+
+std::pair<ordering, bool> super_condorcet_set::elect_inner(
+	const election_t & papers,
+	const std::vector<bool> & hopefuls,
+	int num_candidates, cache_map * cache,
+	bool winner_only) const {
+
+	size_t numcands = hopefuls.size();
+
+	subelections se;
+	se.count_subelections(papers, hopefuls, true);
+
+	disqual_tensor level_disqualifications =
+		se.get_level_disqualifications(hopefuls, true);
+
+	size_t super_cw_idx = 0;
+	bool found_super_condorcet = false;
+
+	std::vector<size_t> copeland_counts(numcands, 0);
+
+	for (size_t i = 0;
+		i < numcands && !found_super_condorcet; ++i) {
+		bool is_super_cw = true;
+
+		for (size_t j = 0;
+			j < numcands /*&& is_super_cw*/; ++j) {
+
+			if (!hopefuls[i]) {
+				continue;
+			}
+			if (!hopefuls[j]) {
+				continue;
+			}
+			if (i == j) {
+				continue;
+			}
+
+			if (!level_disqualifications[numcands][i][j]) {
+				is_super_cw = false;
+			} else {
+				++copeland_counts[i];
+			}
+		}
+
+		if (is_super_cw) {
+			found_super_condorcet = true;
+			super_cw_idx = i;
+		}
+	}
+
+	ordering output;
+
+	for (size_t cand = 0; cand < numcands; ++cand) {
+		if (!hopefuls[cand]) {
+			continue;
+		}
+
+		if (found_super_condorcet && super_cw_idx == cand) {
+			output.insert(candscore(cand, 1));
+		} else {
+			output.insert(candscore(cand, 0));
+		}
+	}
+
+	return std::pair<ordering, bool>(output, false);
+}

src/singlewinner/sets/scw.h

@@ -0,0 +1,26 @@
+// Francois Durand's "Super Condorcet winner": the candidate
+// (if any) who, in resistant set terms, disqualifies everybody
+// else directly.
+
+// I could build on this if necessary.
+
+// Hold on... can this even work? Suppose A~>B, A~>C. Couldn't B>A
+// voters possibly break A~>C? Say they bury C: BAC -> BCA. This
+// breaks A~>C and now A is no longer the Super CW...
+
+#pragma once
+
+#include "../method.h"
+
+class super_condorcet_set : public election_method {
+	public:
+		std::pair<ordering, bool> elect_inner(
+			const election_t & papers,
+			const std::vector<bool> & hopefuls,
+			int num_candidates, cache_map * cache,
+			bool winner_only) const;
+
+		std::string name() const {
+			return "Super Condorcet";
+		}
+};