We present below several examples of how to use the PrefLib-Tools. Further information about all the functions and classes can be found in the reference.

PrefLib Instances

We use different Python classes to deal with the different types of data that are hosted on All these classes inherit from PrefLibInstance, the abstract class that implements all the basic functionalities common to all the others. Let us first discuss the class PrefLibInstance, the other classes will be introduced later.

The most important functionality, is the ability to read and parse PrefLib data. We provide several ways to do so, as illustrated below.

from preflibtools.instances import PrefLibInstance

instance = PrefLibInstance()

PrefLibInstance also stores most of the metadata about the data file.

# Path to the original file, and the name of the file
# The type of the instance and its modification type
# Some potentially related files
# The title of the data file and its description (mainly empty, on purpose)
# Some historical landmark about the data file
# The number of alternatives and their names
for alt, alt_name in instance.alternatives_name.items():
    alternative = alt
    name = alt_name
# The number of voters

Finally, PrefLibInstance also provide the basic functions to write the instance.


As said before, PrefLibInstance is an abstract class, so all the actual stuff only happens in what comes next.

Ordinal Preferences

Preferences that can be represented as orders over the alternatives are called ordinal. The orders can be partial, and/or weak. All these preferences are represented using the class OrdinalInstance. It implements the basic functions required by PrefLibInstance and provide additional metadata that are illustrated below.

from preflibtools.instances import OrdinalInstance

# We can populate the instance by reading a file from PrefLib.
# You can do it based on a URL or on a path to a file
instance = OrdinalInstance()

# Additional members of the class are the orders,  their multiplicity and the number of unique orders
for o in instance.orders:
    order = o
    multiplicity = instance.multiplicity[order]

We represent orders as tuples of tuples (we need them to be hashable), i.e., it is a vector of sets of alternatives where each set represents an indifference class for the voter. Here are some examples of orders.

# The strict and complete order 1 > 2 > 0
strict_order = ((1,), (2,), (0,))
# The weak and complete order (1, 2) > 0 > (3, 4)
weak_order = ((1, 2), (0,), (3, 4))
# The incomplete an weak order (1, 2) > 4
incomplete_order = ((1, 2), (4,))

Now that we know how orders are represented, we can see some example of how to handle orders within the instance.

# Adding preferences to the instance, using different formats
# Simply a list of orders
extra_orders = [((0,), (1,), (2,)), ((2,), (0,), (1,))]
# A vote map, i.e., a dictionary mapping orders to their multiplicity
extra_vote_map = {((0,), (1,), (2,)): 3, ((2,), (0,), (1,)): 2}

# We can access the full profile, i.e., with orders appearing several times
# (according to their multiplicity)

# If we are dealing with strict orders, we can flatten the orders so that ((0,), (1,), (2,))
# is rewritten as (0, 1, 2). This return a list of tuple(order, multiplicity).

# We can access the profile as a vote map

An instance can be populated by reading a file, but also through some sampling procedures that we provide.

# Some statistical culture we provide, here for 5 voters and 10 alternatives
instance = OrdinalInstance()
instance.populate_mallows_mix(5, 10, 3)
instance.populate_urn(5, 10, 76)
instance.populate_IC(5, 10)
instance.populate_IC_anon(5, 10)

To finish, we may want to test some properties of the instance. Let’s start with some basic ones.

from import borda_scores, has_condorcet

# Let's check the Borda scores of the alternatives
# We can also check if the instance has a Condorcet winner

The are plenty of methods to check for the potential single-peakedness of the instance.

from import *

# We can first check if the instance is single-peaked with respect to a given
# axis. This only works for complete orders, they can be weak though.
is_SP = is_single_peaked_axis(instance, [0, 1, 2])
# In general we can test for the single-peakedness of the instance:
# In the case of strict and complete orders;
(is_SP, axis) = is_single_peaked(instance)
# And in the case of weak and complete order (using an ILP solver).
(is_SP, opt_status, axis) = is_single_peaked_ILP(instance)

# Maybe the instance is not single-peaked, but approximately. We can check how close to
# single-peaked it is in terms of voter deletion and alternative deletion.
(num_voter_deleted, opt_status, axis, deleted_voters) = approx_SP_voter_deletion_ILP(instance)
(num_alt_deleted, opt_status, axis, deleted_alts) = approx_SP_alternative_deletion_ILP(instance)

We can also look into single-crossing.

from import is_single_crossing

# Testing if the instance is single-crossing

Finally, we can talk about distances between the orders of the instance.

from import distance_matrix, spearman_footrule_distance
from import kendall_tau_distance, sertel_distance

# We can create the distance matrix between any two orders of the instance
distance_matrix(instance, kendall_tau_distance)
distance_matrix(instance, spearman_footrule_distance)
distance_matrix(instance, sertel_distance)

Categorical Preferences

Categorical preferences represent scenario in which voters were asked to place alternatives into some categories. It is also assumed that there is an ordering of the categories inducing some preference between them. The typical example of categorical preferences is approval ballots, in which the categories are YES and NO.

This types of preferences are represented using the CategoricalInstance class.

from preflibtools.instances import CategoricalInstance

instance = CategoricalInstance()

# Additional members of the class are related to the categories themselves
for cat, cat_name in instance.categories_name.items():
    category = cat
    name_of_the_category = cat_name
# But also to the preferences
for p in instance.preferences:
    preferences = p
    multiplicity = instance.multiplicity[p]

Matching Preferences

Matching preferences cover settings in which agents are to be matched to one another, and they have affinity scores between each others. The typical example for such preferences hosted on is that of kidney transplant where donors and patients are to be matched. The class MatchingInstance covers these.

This class inherits both from PrefLibInstance and from WeightedDiGraph. This means that on top of the usual instance machinery, it also has all the graph related members and methods.

from preflibtools.instances import MatchingInstance

instance = MatchingInstance()

# The instance has a single new member: the number of edges in the graph

# ...and an adjacency list implementation of the weighted directed graph
instance.nodes() # returns the set of nodes
instance.edges() # returns the set of edges in the format (n1, n2, weight)
instance.neighbours(n) # returns the neighbours of node n
instance.outgoing_edges(n) # returns the edges going out of n
instance.add_node(n) # to add a node n
instance.add_edge(n1, n2, weight) # to add the edge (n1, n2, weight)