Discussion:
[EM] EXACT, a Majority Judgment-like IBIFA variant w/FBC and IBI
Ted Stern
2017-12-25 23:43:35 UTC
Chris Benham proposed IBIFA in May and June, 2010, on the election-methods
mailing list:

http://lists.electorama.com/pipermail/election-methods-
electorama.com/2010-May/091807.html

http://election-methods.electorama.narkive.com/KdBxpweB/irrelevant-ballots-
independent-fallback-approval-ibifa

http://wiki.electorama.com/wiki/IBIFA

IBIFA is, as originally stated, a "Bucklin-like method meeting Favorite
Betrayal and Irrelevant Ballots." Its key principle is to compare the
ballots voting for a candidate at-or-above a particular rating to the
most-approved candidate on the complementary ballots. When the former
exceeds the latter, a meaningful threshold has been crossed, unlike the
arbitrary 50% threshold of median rating methods. This is what enables
IBIFA to yield the same result if irrelevant ballots are added or dropped.
By construction, IBIFA is cloneproof.

With this in mind, I realized that a minor modification of IBIFA would make
it more like Majority Judgment, reducing later-harm and improving Condorcet
consistency (though not completely), while satisfying the same criteria as
MJ.

IBIFA, simply stated, does the following:

- Find the highest rating R, for which there is at least one candidate X
who is rated *at or above level R* on more ballots than any candidate is
approved on ballots that rate X below R.
- If there is more than one such candidate X, elect the candidate X with
the most ballots rating X at R or above.
- If no candidates satisfy the first criterion, for any approved rating
R, elect the candidate with the highest approval over all ballots.

My modification is inserted with emphasis added.

- Find the highest rating R, for which there is at least one candidate X
who is rated *at or above level R* on more ballots than any candidate is
approved on ballots which rate X below R.
- If there is more than one such candidate X, *then if there is at least
one candidate Y who is rated above R on more ballots than the highest
approved candidate on ballots that rate Y below R, elect the candidate Y
with the most ballots rating Y above R.*
- *Otherwise, *elect the candidate X with the most ballots rating X at R
or above.
- If no candidates satisfy the first criterion, for any approved rating
R, elect the candidate with the highest approval over all ballots.

I call this IBIFA variant "EXACT", because it uses an EXclusive Approval
Comparison Threshold. That is, the candidate compared to X is the one with
maximum approval on ballots that *exclude* votes for X at some rating or
above. Like IBIFA, it is also cloneproof.

For EXACT, it is convenient to keep track of co-approval: the approval for
candidates X[j] on a ballot containing candidate X[i] with rating k:

for ballot in ballots:
for candidate i on ballot with score k:
if k approved:
for candidate j on ballot with score m:
if m approved:
W[k,i,j] += 1

Note that W[k,i,i] is the total approval for candidate X[i] at rating k,
and the total approval for candidate X[i] at rating k and higher is the sum
of W[k,i,i] over all approved ratings k.

It should then be clear that the approval for any candidate j on a ballot
that rates X[i] at R or higher is

Approval[j] - W[R,i,j] - W[R+1,i,j] ... - W[MaxScore,i,j]

The EXACT score for a candidate is tuple similar to Majority Judgment's

EXACT score for candidate X = (R, S, T)

where R is the rating at which X's votes at or above R are greater than
the highest approved candidate on ballots excluding X at R or above.;

If the number of ballots with X at rating R+1 and above is greater than
those of the highest approved candidate on ballots excluding X at ratings R
and above, then S = R+1, and T = votes for X at R+1 and above.

Otherwise, S = R and T = votes for X at R and above.

By sorting these tuples in descending order, one gets, as with Majority
Judgment, an EXACT ranking for the candidates.

EXACT satisfies all the same properties as Majority Judgment, and in
addition, is irrelevant-ballot-immune (IBI). That is, a ballot containing
approval only for non-contending candidates won't affect the results.

EXACT does require several N^2 arrays for summable storage, but note that
no sorting of the ballots is required as with pairwise methods.
Kristofer Munsterhjelm
2018-02-04 14:53:07 UTC
Post by Ted Stern
Chris Benham proposed IBIFA in May and June, 2010, on the
http://lists.electorama.com/pipermail/election-methods-electorama.com/2010-May/091807.html
<http://lists.electorama.com/pipermail/election-methods-electorama.com/2010-May/091807.html>
http://election-methods.electorama.narkive.com/KdBxpweB/irrelevant-ballots-independent-fallback-approval-ibifa
<http://election-methods.electorama.narkive.com/KdBxpweB/irrelevant-ballots-independent-fallback-approval-ibifa>
http://wiki.electorama.com/wiki/IBIFA
<http://wiki.electorama.com/wiki/IBIFA>
IBIFA is, as originally stated, a "Bucklin-like method meeting Favorite
Betrayal and Irrelevant Ballots." Its key principle is to compare the
ballots voting for a candidate at-or-above a particular rating to the
most-approved candidate on the complementary ballots. When the former
exceeds the latter, a meaningful threshold has been crossed, unlike the
arbitrary 50% threshold of median rating methods. This is what enables
IBIFA to yield the same result if irrelevant ballots are added or
dropped. By construction, IBIFA is cloneproof.
With this in mind, I realized that a minor modification of IBIFA would
make it more like Majority Judgment, reducing later-harm and improving
Condorcet consistency (though not completely), while satisfying the same
criteria as MJ.
Do you think it's possible to generalize that strategy to handle
multiwinner elections as well? I can't see any obvious ways, but it
would be nice if one could make multiwinner methods with implicit
thresholds as well, since the vast majority uses explicit thresholds
(usually the Droop quota).
Post by Ted Stern
EXACT does require several N^2 arrays for summable storage, but note
that no sorting of the ballots is required as with pairwise methods.
Pairwise methods don't strictly require that ballots are sorted. E.g.
the following will produce a Condorcet matrix (if there's no truncation
or equal rank):

for i = 1 to num ballots
for j = 1 to num candidates
c1 = candidate ranked at jth place on the ith ballot

for k = j+1 to num candidates
c2 = candidate ranked at kth place on the ith ballot
matrix[c1 beats c2] += weight of ballot i

It's a bit of a nitpick, though :-)
----
Election-Methods mailing list - see http://electorama.com/em for list info
Ted Stern
2018-02-06 19:00:43 UTC
Post by Kristofer Munsterhjelm
Post by Ted Stern
Chris Benham proposed IBIFA in May and June, 2010, on the
http://lists.electorama.com/pipermail/election-methods-elect
orama.com/2010-May/091807.html
<http://lists.electorama.com/pipermail/election-methods-elec
torama.com/2010-May/091807.html>
http://election-methods.electorama.narkive.com/KdBxpweB/irre
levant-ballots-independent-fallback-approval-ibifa
<http://election-methods.electorama.narkive.com/KdBxpweB/irr
elevant-ballots-independent-fallback-approval-ibifa>
http://wiki.electorama.com/wiki/IBIFA
<http://wiki.electorama.com/wiki/IBIFA>
IBIFA is, as originally stated, a "Bucklin-like method meeting Favorite
Betrayal and Irrelevant Ballots." Its key principle is to compare the
ballots voting for a candidate at-or-above a particular rating to the
most-approved candidate on the complementary ballots. When the former
exceeds the latter, a meaningful threshold has been crossed, unlike the
arbitrary 50% threshold of median rating methods. This is what enables
IBIFA to yield the same result if irrelevant ballots are added or
dropped. By construction, IBIFA is cloneproof.
With this in mind, I realized that a minor modification of IBIFA would
make it more like Majority Judgment, reducing later-harm and improving
Condorcet consistency (though not completely), while satisfying the same
criteria as MJ.
Do you think it's possible to generalize that strategy to handle
multiwinner elections as well? I can't see any obvious ways, but it would
be nice if one could make multiwinner methods with implicit thresholds as
well, since the vast majority uses explicit thresholds (usually the Droop
quota).
Single-winner rated methods can be adapted to an ER-Bucklin-Droop
multiwinner method. Just choose each seat using the single-winner method
and weighted ballots.

Then reweight the ballots by finding the score at-and-above which at least
one Droop quota of voters approves the seat winner, and reweight those
ballots to remove one Droop quota.

The difference from straight ER-Bucklin multiwinner is that the
quota-finding score is *not* the one used to determine the seat winner.
Post by Kristofer Munsterhjelm
EXACT does require several N^2 arrays for summable storage, but note
Post by Ted Stern
that no sorting of the ballots is required as with pairwise methods.
Pairwise methods don't strictly require that ballots are sorted. E.g. the
following will produce a Condorcet matrix (if there's no truncation or
for i = 1 to num ballots
for j = 1 to num candidates
c1 = candidate ranked at jth place on the ith ballot
for k = j+1 to num candidates
c2 = candidate ranked at kth place on the ith ballot
matrix[c1 beats c2] += weight of ballot i
It's a bit of a nitpick, though :-)
I apologize for my earlier assertion. When I tried coding the pairwise
array myself, using the numpy package in Python, I found a very compact way
to do so, much along those lines. Using the matrix optimized numpy
package, imported as "np",

for ballot, w in zip(ballots,weight):
for v in range(1,maxscore): # Assuming all rated
candidates are approved
A += w * np.multiply.outer(np.where(ballot==v,1,0),
np.where(ballot<=v,1,0))

In other words, the matrix update to the pairwise array is, for each rating
v, the outer product of (a) a vector with ones where candidates have score
v, with (b) another vector with ones where candidates have scores less than
or equal (or less than) v.
Chris Benham
2018-02-14 11:59:21 UTC
Post by Ted Stern
My modification is inserted with emphasis added.
* Find the highest rating R, for which there is at least one
candidate X who is rated _at or above level R_ on more ballots
than any candidate is approved on ballots which rate X below R.
* If there is more than one such candidate X, /then if there is at
least one candidate Y who is rated _above R_ on more ballots than
the highest approved candidate on ballots that rate Y below R,
elect the candidate Y with the most ballots rating Y above R./
* /Otherwise, /elect the candidate X with the most ballots rating X
at R or above.
* If no candidates satisfy the first criterion, for any approved
rating R, elect the candidate with the highest approval over all
ballots.
To be more clear, shouldn't the second line read something like:

If there is more than one such candidate X, /then*among those
candidates* if there is at least one candidate Y who is rated _above R_
on more ballots than the highest approved candidate on ballots that rate
Y below R, elect the candidate Y with the most ballots rating Y above R./

?
Â The method looks good, AFICT.

Chris Benham
Post by Ted Stern
Chris Benham proposed IBIFA in May and June, 2010, on the
http://lists.electorama.com/pipermail/election-methods-electorama.com/2010-May/091807.html
<http://lists.electorama.com/pipermail/election-methods-electorama.com/2010-May/091807.html>
http://election-methods.electorama.narkive.com/KdBxpweB/irrelevant-ballots-independent-fallback-approval-ibifa
<http://election-methods.electorama.narkive.com/KdBxpweB/irrelevant-ballots-independent-fallback-approval-ibifa>
http://wiki.electorama.com/wiki/IBIFA
<http://wiki.electorama.com/wiki/IBIFA>
IBIFA is, as originally stated, a "Bucklin-like method meeting
Favorite Betrayal and Irrelevant Ballots."Â  Its key principle is to
compare the ballots voting for a candidate at-or-above a particular
rating to the most-approved candidate on the complementary ballots.Â
When the former exceeds the latter, a meaningful threshold has been
crossed, unlike the arbitrary 50% threshold of median rating methods.Â
This is what enables IBIFA to yield the same result if irrelevant
ballots are added or dropped.Â  By construction, IBIFA is cloneproof.
With this in mind, I realized that a minor modification of IBIFA would
make it more like Majority Judgment, reducing later-harm and improving
Condorcet consistency (though not completely), while satisfying the
same criteria as MJ.
* Find the highest rating R, for which there is at least one
candidate X who is rated _at or above level R_Â on more ballots
than any candidate is approved on ballots that rate X below R.
* If there is more than one such candidate X, elect the candidate X
with the most ballots rating X at R or above.
* If no candidates satisfy the first criterion, for any approved
rating R, elect the candidate with the highest approval over all
ballots.
My modification is inserted with emphasis added.
* Find the highest rating R, for which there is at least one
candidate X who is rated _at or above level R_ on more ballots
than any candidate is approved on ballots which rate X below R.
* If there is more than one such candidate X, /then if there is at
least one candidate Y who is rated _above R_ on more ballots than
the highest approved candidate on ballots that rate Y below R,
elect the candidate Y with the most ballots rating Y above R./
* /Otherwise, /elect the candidate X with the most ballots rating X
at R or above.
* If no candidates satisfy the first criterion, for any approved
rating R, elect the candidate with the highest approval over all
ballots.
I call this IBIFA variant "EXACT", because it uses an EXclusive
Approval Comparison Threshold.Â  That is, the candidate compared to X
is the one with maximum approval on ballots that _exclude_ votes for X
at some rating or above.Â  Like IBIFA, it is also cloneproof.
For EXACT, it is convenient to keep track of co-approval: the approval
Â W[k,i,j] += 1
Note that W[k,i,i] is the total approval for candidate X[i] at rating
k, and the total approval for candidate X[i] at rating k and higher is
the sum of W[k,i,i] over all approved ratings k.
It should then be clear that the approval for any candidate j on a
ballot that rates X[i] at R or higher is
Â  Â  Â  Approval[j] - W[R,i,j] - W[R+1,i,j] ... - W[MaxScore,i,j]
The EXACT score for a candidate is tuple similar to Majority
EXACT score for candidate X = (R, S, T)
where R is the rating at which X's votes at or above R are greater
than theÂ  highest approved candidate on ballots excluding X at R
or above.;
If the number of ballots with X at rating R+1 and above is greater
than those of the highest approved candidate on ballots excluding
X at ratings R and above, then S = R+1, and T = votes for X at R+1
and above.
Otherwise, S = R and T = votes for X at R and above.
By sorting these tuples in descending order, one gets, as with
Majority Judgment, an EXACT ranking for the candidates.
EXACT satisfies all the same properties as Majority Judgment, and in
addition, is irrelevant-ballot-immune (IBI). That is, a ballot
containing approval only for non-contending candidates won't affect
the results.
EXACT does require several N^2 arrays for summable storage, but note
that no sorting of the ballots is required as with pairwise methods.
---
This email has been checked for viruses by AVG.
http://www.avg.com
Ted Stern
2018-02-14 19:46:42 UTC
Hi Chris,

Your insertion is absolutely correct and does not change the method, but I
think it is implied automatically.

If a candidate Y is rated above R on more ballots than the highest approved
candidate on ballots that rate Y below R, then Y's above-R number of
ballots is a lower bound for the number of ballots that rate Y at-or-above
R. So Y would always be "among those candidates".

Ted
Post by Ted Stern
My modification is inserted with emphasis added.
- Find the highest rating R, for which there is at least one candidate
X who is rated *at or above level R* on more ballots than any
candidate is approved on ballots which rate X below R.
- If there is more than one such candidate X, *then if there is at
least one candidate Y who is rated above R on more ballots than the highest
approved candidate on ballots that rate Y below R, elect the candidate Y
with the most ballots rating Y above R.*
- *Otherwise, *elect the candidate X with the most ballots rating X at
R or above.
- If no candidates satisfy the first criterion, for any approved
rating R, elect the candidate with the highest approval over all ballots.
If there is more than one such candidate X, *then among those candidates
if there is at least one candidate Y who is rated above R on more ballots
than the highest approved candidate on ballots that rate Y below R, elect
the candidate Y with the most ballots rating Y above R.*
?
The method looks good, AFICT.
Chris Benham
Chris Benham proposed IBIFA in May and June, 2010, on the election-methods
http://lists.electorama.com/pipermail/election-methods-elect
orama.com/2010-May/091807.html
http://election-methods.electorama.narkive.com/KdBxpweB/
irrelevant-ballots-independent-fallback-approval-ibifa
http://wiki.electorama.com/wiki/IBIFA
IBIFA is, as originally stated, a "Bucklin-like method meeting Favorite
Betrayal and Irrelevant Ballots." Its key principle is to compare the
ballots voting for a candidate at-or-above a particular rating to the
most-approved candidate on the complementary ballots. When the former
exceeds the latter, a meaningful threshold has been crossed, unlike the
arbitrary 50% threshold of median rating methods. This is what enables
IBIFA to yield the same result if irrelevant ballots are added or dropped.
By construction, IBIFA is cloneproof.
With this in mind, I realized that a minor modification of IBIFA would
make it more like Majority Judgment, reducing later-harm and improving
Condorcet consistency (though not completely), while satisfying the same
criteria as MJ.
- Find the highest rating R, for which there is at least one candidate
X who is rated *at or above level R* on more ballots than any
candidate is approved on ballots that rate X below R.
- If there is more than one such candidate X, elect the candidate X
with the most ballots rating X at R or above.
- If no candidates satisfy the first criterion, for any approved
rating R, elect the candidate with the highest approval over all ballots.
My modification is inserted with emphasis added.
- Find the highest rating R, for which there is at least one candidate
X who is rated *at or above level R* on more ballots than any
candidate is approved on ballots which rate X below R.
- If there is more than one such candidate X, *then if there is at
least one candidate Y who is rated above R on more ballots than the highest
approved candidate on ballots that rate Y below R, elect the candidate Y
with the most ballots rating Y above R.*
- *Otherwise, *elect the candidate X with the most ballots rating X at
R or above.
- If no candidates satisfy the first criterion, for any approved
rating R, elect the candidate with the highest approval over all ballots.
I call this IBIFA variant "EXACT", because it uses an EXclusive Approval
Comparison Threshold. That is, the candidate compared to X is the one with
maximum approval on ballots that *exclude* votes for X at some rating or
above. Like IBIFA, it is also cloneproof.
For EXACT, it is convenient to keep track of co-approval: the approval for
W[k,i,j] += 1
Note that W[k,i,i] is the total approval for candidate X[i] at rating k,
and the total approval for candidate X[i] at rating k and higher is the sum
of W[k,i,i] over all approved ratings k.
It should then be clear that the approval for any candidate j on a ballot
that rates X[i] at R or higher is
Approval[j] - W[R,i,j] - W[R+1,i,j] ... - W[MaxScore,i,j]
The EXACT score for a candidate is tuple similar to Majority Judgment's
EXACT score for candidate X = (R, S, T)
where R is the rating at which X's votes at or above R are greater than
the highest approved candidate on ballots excluding X at R or above.;
If the number of ballots with X at rating R+1 and above is greater than
those of the highest approved candidate on ballots excluding X at ratings R
and above, then S = R+1, and T = votes for X at R+1 and above.
Otherwise, S = R and T = votes for X at R and above.
By sorting these tuples in descending order, one gets, as with Majority
Judgment, an EXACT ranking for the candidates.
EXACT satisfies all the same properties as Majority Judgment, and in
addition, is irrelevant-ballot-immune (IBI). That is, a ballot containing
approval only for non-contending candidates won't affect the results.
EXACT does require several N^2 arrays for summable storage, but note that
no sorting of the ballots is required as with pairwise methods.