# Majority Rule¶

The Majority Rule model is a discrete model of opinion dynamics, proposed to describe public debates [1].

Agents take discrete opinions ±1, just like the Voter model. At each time step a group of r agents is selected randomly and they all take the majority opinion within the group.

The group size can be fixed or taken at each time step from a specific distribution. If r is odd, then the majority opinion is always defined, however if r is even there could be tied situations. To select a prevailing opinion in this case, a bias in favour of one opinion (+1) is introduced.

This idea is inspired by the concept of social inertia [2].

## Statuses¶

During the simulation a node can experience the following statuses:

Name Code
Susceptible 0
Infected 1

## Parameters¶

Name Type Value Type Default Mandatory Description
q Model int in [0, V(G)]   True Number of neighbours

The initial infection status can be defined via:

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

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.MajorityRuleModel.MajorityRuleModel(graph)
MajorityRuleModel.__init__(graph)

Model Constructor

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

Set the initial model configuration

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

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

### Describe¶

MajorityRuleModel.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
MajorityRuleModel.get_status_map(self)

Specify the statuses allowed by the model and their numeric code

Returns: a dictionary (status->code)

### Execute Simulation¶

MajorityRuleModel.iteration(self)

Execute a single model iteration

Returns: Iteration_id, Incremental node status (dictionary node->status)
MajorityRuleModel.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 Majority Rule 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.MajorityRuleModel as mr

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

# Model selection
model = mr.MajorityRuleModel(g)
config = mc.Configuration()