# Voter¶

The Voter model is one of the simplest models of opinion dynamics, originally introduced to analyse competition of species [1] and soon after applied to model elections [2].

The model assumes the opinion of an individual to be a discrete variable ±1.

The state of the population varies based on a very simple update rule: at each iteration, a random individual is selected, who then copies the opinion of one random neighbour.

Starting from any initial configuration, on a complete network the entire population converges to consensus on one of the two options. The probability that consensus is reached on opinion +1 is equal to the initial fraction of individuals holding that opinion [3].

## Statuses¶

During the simulation a node can experience the following statuses:

Name Code
Susceptible 0
Infected 1

## Parameters¶

The initial infection status can be defined via:

• percentage_infected: Model Parameter, float in [0, 1]
• Infected: Status Parameter, set of nodes

The initial blocked nodes can be defined via:

• percentage_blocked: Model Parameter, float in [0, 1]
• Blocked: Status Parameter, set of nodes

In both cases, the two options are mutually exclusive and the latter takes precedence over the former.

## Methods¶

The following class methods are made available to configure, describe and execute the simulation:

### Configure¶

class ndlib.models.opinions.VoterModel.VoterModel(graph)
VoterModel.__init__(graph)

Model Constructor

Parameters: graph – A networkx graph object
VoterModel.set_initial_status(self, configuration)

Set the initial model configuration

Parameters: configuration – a ndlib.models.ModelConfig.Configuration object
VoterModel.reset(self)

Reset the simulation setting the actual status to the initial configuration.

### Describe¶

VoterModel.get_info(self)

Describes the current model parameters (nodes, edges, status)

Returns: a dictionary containing for each parameter class the values specified during model configuration
VoterModel.get_status_map(self)

Specify the statuses allowed by the model and their numeric code

Returns: a dictionary (status->code)

### Execute Simulation¶

VoterModel.iteration(self)

Execute a single model iteration

Returns: Iteration_id, Incremental node status (dictionary node->status)
VoterModel.iteration_bunch(self, bunch_size)

Execute a bunch of model iterations

Parameters: bunch_size – the number of iterations to execute node_status – if the incremental node status has to be returned. a list containing for each iteration a dictionary {“iteration”: iteration_id, “status”: dictionary_node_to_status}

## Example¶

In the code below is shown an example of instantiation and execution of a Voter model simulation on a random graph: we set the initial infected node set to the 10% of the overall population.

import networkx as nx
import ndlib.models.ModelConfig as mc
import ndlib.models.opinions.VoterModel as vt

# Network topology
g = nx.erdos_renyi_graph(1000, 0.1)

# Model selection
model = vt.VoterModel(g)
config = mc.Configuration()