+# election library -- a ruby library for elections
+# copyright © 2005 MIT Media Lab and Benjamin Mako Hill
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+# 02110-1301, USA.
+
+#################################################################
+## ==== condorcet.rb ====
+##
+## This file contains Condorcet election methods. Currently this
+## includes a pure condorcet and a CloneproofSSD implementation
+## modeled after the Python-based Debian project election code and
+## that gives the same results in several tested corner cases.
+#################################################################
+
+##################################################################
+## CondorcetVote Classes and SubClasses
+##
+## The CondorcetVote class is subclassed by the PureCondorcetVote and
+## the CloneproofSSDVote classes but should not be used directly.
+
+class CondorcetVote < ElectionVote
+
+ attr_accessor :results
+
+ def initialize(votes=nil)
+ unless defined?(@candidates)
+ @candidates = Array.new
+ votes.each do |vote_row|
+ vote_row = vote_row.flatten if vote_row.class == Array
+ vote_row.each do |vote|
+ @candidates << vote unless @candidates.include?(vote)
+ end
+ end
+ end
+ super(votes)
+ @results = Array.new
+ end
+
+ def tally_vote(vote=nil)
+
+ vote.each_with_index do |winners, index|
+ if vote.flatten.length < @candidates.length
+ implied_losers = @candidates.select { |c| not vote.flatten.include?(c) }
+ vote.push(implied_losers)
+ end
+ if vote.length - 1 == index
+ losers = []
+ else
+ losers = vote.flatten.last( vote.flatten.length - index - 1)
+ end
+
+ losers.each do |place|
+ place = [place] unless place.class == Array
+ place.each do |loser|
+
+ winners = [winners] unless winners.class == Array
+ next if winners.include?(loser)
+ winners.each do |winner|
+ @votes[winner] = Hash.new unless @votes.has_key?(winner)
+ @votes[loser] = Hash.new unless @votes.has_key?(loser)
+
+ if @votes[winner].has_key?(loser)
+ @votes[winner][loser] += 1
+ else
+ @votes[winner][loser] = 1
+ end
+
+ # make sure we have a comparable object
+ @votes[loser][winner] = 0 unless @votes[loser].has_key?( winner )
+ end
+ end
+ end
+ end
+ end
+
+ def results
+ if @results.size < 2 && (not @candidates.empty?)
+ tabulate
+ end
+ @results
+ end
+
+ def result
+ find_only_winner unless @winner
+ @winner
+ end
+
+ protected
+
+ def verify_vote(vote=nil)
+ vote.instance_of?( Array ) and
+ vote == vote.uniq
+ end
+
+ def tabulate
+ find_only_winner unless @winner
+ until @candidates.empty?
+ aResult = resultFactory( self )
+ @results << aResult.winners
+ filter_out(aResult)
+ end
+ end
+
+ def find_only_winner
+ @winner = resultFactory( self )
+ @results << @winner.winners
+ filter_out(@winner)
+ end
+
+end
+
+class PureCondorcetVote < CondorcetVote
+ def resultFactory(init)
+ PureCondorcetResult.new(init)
+ end
+end
+
+class CloneproofSSDVote < CondorcetVote
+ def resultFactory(init)
+ CloneproofSSDResult.new(init)
+ end
+
+end
+
+
+##################################################################
+## CondorcetResult Classes and SubClasses
+##
+## The CondorcetResult class is subclassed by the PureCondorcetResult
+## and the CloneproofSSDResult classes but should not be used
+## directly.
+
+class CondorcetResult < ElectionResult
+ attr_reader :matrix
+
+ def initialize(voteobj=nil)
+ unless voteobj and voteobj.kind_of?( CondorcetVote )
+ raise ArgumentError, "You must pass a CondorcetVote array.", caller
+ end
+ super(voteobj)
+ @matrix = voteobj.votes
+ end
+
+ def victories_and_ties
+ victors = Array.new
+ ties = Array.new
+ victories = Hash.new
+ candidates = @matrix.keys.sort
+
+ candidates.each do |candidate|
+ candidates.each do |challenger|
+ next if candidate == challenger
+ diff = @matrix[candidate][challenger] - @matrix[challenger][candidate]
+ if diff > 0
+ victors << [candidate, challenger, diff]
+ elsif diff == 0 && ties.include?([challenger, candidate]) == false
+ ties << [candidate, challenger]
+ end
+ end
+ end
+
+ victors.each do |list|
+ if victories.has_key?(list[0])
+ victories[list[0]][list[1]] = list[2]
+ else
+ victories[list[0]] = Hash.new
+ victories[list[0]][list[1]] = list[2]
+ end
+ end
+
+ return victories, ties
+ end
+
+ protected
+ def defeats(candidates=nil, votes=nil)
+ candidates ||= @election.candidates || []
+ # we're assumign that if there are candidates, there must be at
+ # least one vote for them
+ votes ||= @election.votes
+
+ defeats = Array.new
+ candidates.each do |candidate|
+ candidates.each do |challenger|
+ next if candidate == challenger
+ if votes[candidate][challenger] > votes[challenger][candidate]
+ defeats << [ candidate, challenger ]
+ end
+ end
+ end
+
+ defeats
+ end
+
+end
+
+class PureCondorcetResult < CondorcetResult
+ def initialize(voteobj=nil)
+ super(voteobj)
+ self.condorcet()
+ end
+
+ protected
+
+ def condorcet
+ votes = @election.votes
+ candidates = @election.candidates
+
+ unless votes.length > 0 and candidates.length > 0
+ return @winners=[]
+ end
+
+ victors = Hash.new
+ candidates.each do |candidate|
+ victors[candidate] = Array.new
+ end
+
+ self.defeats.each do |pair|
+ winner, loser = *pair
+ victors[winner] << loser
+ end
+
+ victory_margin = 1
+ while true
+ winners = @election.candidates.find_all do |candidate|
+ victors[candidate].length == @election.candidates.length - victory_margin
+ end
+ if winners.length > 0
+ @winners = winners
+ return @winners
+ else
+ victory_margin += 1
+ end
+ end
+ end
+end
+
+class CloneproofSSDResult < CondorcetResult
+ def initialize(voteobj=nil)
+ super(voteobj)
+ @winners = self.cpssd()
+ end
+
+ protected
+
+ def cpssd
+ votes = @election.votes
+ candidates = @election.candidates.dup
+
+ def in_schwartz_set?(candidate, candidates, transitive_defeats)
+ candidates.each do |challenger|
+ next if candidate == challenger
+
+ if transitive_defeats.include?( [ challenger, candidate ] ) and
+ not transitive_defeats.include?( [ candidate, challenger ] )
+ return false
+ end
+ end
+ return true
+ end
+
+ loop do
+
+ # see the array with the standard defeats
+ transitive_defeats = self.defeats(candidates, votes)
+ defeats_hash = Hash.new
+ transitive_defeats.each { |td| defeats_hash[td] = 1 }
+
+ candidates = [candidates] unless candidates.class == Array
+ candidates.each do |cand1|
+ candidates.each do |cand2|
+ unless cand1 == cand2
+ candidates.each do |cand3|
+ if not cand2 == cand3 and
+ not cand1 == cand3 and
+ defeats_hash[[cand2, cand1]] and
+ defeats_hash[[cand1, cand3]] and
+ not defeats_hash[[cand2, cand3]]
+ transitive_defeats << [cand2, cand3]
+ defeats_hash[[cand2, cand3]] = 1
+ end
+ end
+ end
+ end
+ end
+
+ schwartz_set = Array.new
+ candidates.each do |candidate|
+ if in_schwartz_set?(candidate, candidates, transitive_defeats)
+ schwartz_set << candidate
+ end
+ end
+
+ candidates = schwartz_set
+
+ # look through the schwartz set now for defeats
+ defeats = self.defeats(candidates, votes)
+
+ # it's a tie or there's only one option
+ break if defeats.length == 0
+
+ def is_weaker_defeat?( pair1, pair2 )
+ votes = @election.votes
+ if votes[pair1[0]][pair1[1]] > votes[pair2[0]][pair2[1]]
+ return true
+ elsif votes[pair1[0]][pair1[1]] == votes[pair2[0]][pair2[1]] and
+ votes[pair1[1]][pair1[0]] > votes[pair2[1]][pair2[0]]
+ return true
+ else
+ false
+ end
+ end
+
+ defeats.sort! do |pair1, pair2|
+ if is_weaker_defeat?( pair1, pair2 )
+ +1
+ elsif is_weaker_defeat?( pair2, pair1 )
+ -1
+ else
+ 0
+ end
+ end
+
+ votes[defeats[0][0]][defeats[0][1]] = 0
+ votes[defeats[0][1]][defeats[0][0]] = 0
+
+ end
+
+ return candidates
+ end
+
+end
projects / rubyvote / commitdiff