Participatory Disinformation

1 collaborator

WHAT IS IT?

The purpose of this model is to simulate the top-down/bottom-up dynamics of what has come to be known as "participatory disinformation."

See the article ["What is participatory disinformation?"](https://www.cip.uw.edu/2021/05/26/participatory-disinformation-kate-starbird/ ) for a description of the real-world phenomenon. This is based on the work of researchers at the University of Washington Center for an Informed Public, et al, in the context of disinformation about the 2020 United States presidential election.

In short, participatory disinformation describes the feedback loop by which disinformation about a particular topic or "frame" is dissimenated in a top-down fashion by political elites to their audiences, who then produce their own false/misleading rumors about the topic in a bottom-up participatory manner. These new rumors are then "traded-up" the media chain by connected social media influencers in an attempt to reach the ear of the political elites. Finally the political elites echo these new rumors back to the audiences who originally created them, reinforcing the frame of the disinformation story.

Model Scope

This NetLogo model focuses on a particular scope of the problem, specifically:

Specific unique rumors spread by political elites in a top-down manner to their audiences
Audience members who adopt rumors from these elites and from their peers in a social network
The audience members sporadically generate new rumors and communicate them with each other
The new rumors are further communmicated by influencers within the audience in an attempt to get them adopted by the elites
Upon adoption, the elites spread the new rumors back to the audiences

The original real-world particpiatory disinformation phenomenon also contains other dynamics that are not included in this model, such as the audience building a sense of collective grievance, and political elites mobilizing their agrieved audiences into collective action. These features are out of the scope of this model and are not represented in the simulation.

HOW IT WORKS

Agents

This model contains three types of agent breeds: elites, regulars, and influencers.

elites -- represent the political elite agents whose rumors are adopted by the audience (regular and influencer) agents.
regulars -- represent the audience agents who generate new rumors, and adopt and spread rumors amongst each other in the network.
influencers -- represent different audience agents whose rumors will be adopted by the elites. They also adopt and spread rumors in the network.

In this documentation we sometimes refer to the combined set of regular and influencer agents together as "audience" agents where it is convenient. However "audience agents" are not a specific type of named breed in the model.

Agent Properties

Every agent, regardless of its breed, posesses a property called rumors-heard?.

rumors-heard? -- a bitstring (from the NetLogo bitstring extension), where each bit represents one of the unique rumors that can be adopted. If the bit is 1 or true, the specific rumor has been adopted. If the bit is 0 or false, the rumor has not been adopted.

Agents adopt a rumor from another agent by looking for the first unheard rumor in another agent's bitstring and setting the corresponding bit from 0 to 1 in their own rumors-heard? bitstring.

Regular and influencer agents start with no rumors heard. Elite agents start with a single random rumor heard.

Agent Actions

During the execution of the model, the agents perform the following actions each step:

Regular and influencer agents

Regular agents and influencer agents will attempt to adopt from elites, adopt from the network, generate rumors, and forget rumors.

Adopt from elites -- The agent has a random chance of adopting the first undeard rumor from the elite agents, based on the agent's distribution of exposure to the elites (see Model Environment).
Adopt from the network -- The agent has a random chance of adopting the first unheard rumor from a random one of its neighbors, if any, based on the fraction of neighbors who have heard any rumors.
Generate rumors -- The agent has a random chance of spontaneously "learning" a random rumor. It is possible that this rumor was already heard before.
Forget rumors -- The agent has a random chance of spontaneously "unlearning" a random rumor.

By default, influencers will not generate rumors, but this behavior is controlled by a switch.

It is also possible to limit rumor generation and rumor forgetting behavior to only a single agent each step via switches.

Elite agents

Elite agents will attempt to trade-up rumors from influencers:

Trade-up to elites: The elite will select a random influencer agent and attempt to adopt the first unherad rumor from it, if any.

Model Environment

The model environment consists of two significan features: patch coloring to control the distribution of elite exposure to regular agents for rumor adoption from elites, and a network connecting regular and influencer agents that controls network exposure for rumor adoption from other agents in the network.

Patch coloring is used to indicate which audience agents have a chance of adopting rumors from the elites, which is called elite exposure in the model. There are three different variations of elite exposure:

uniform: all audience agents have a chance of adopting from elites
irregular: only certain irregular clusters of patches are colored, based on a voting algorithm, and agents on those colored patches have a chance of adoption
block: a contiguous block of patches are colored and agents on those colored patches have a chance of adoption

Patches colored green do not have elite exposure, while patches colored light red do have elite exposure.

The network layout is used to connect audience agents (regulars and influencers) together in a simulation of a social network. Agents have a chance of adopting rumors from the neighbors to which they are connected in the network, with a greater chance based on the relative number of their neighbors who have also adopted any rumors. There are three different network layouts:

Preferential attachment
Random
Small world (uses the Watts Strogatz algorithm to get a better small world layout)

These different layouts do not change the functional behavior of the model, but only determine the structure and distribution of the connections between networked agents.

Setup and Go Procedures

The setup procedure executes the following steps to initialize the model:

Runs the clear-all function to clear everything between executions
Sets a default shape for each of the three agent breeds
Sets up the network by generating a network with num-people number of "audience" agents based on the network-type and initializes the agents' rumors-heard? bitstring to set all rumors to false
Randomly selects some fraction of the agents to be influencer agents
Sets the rest of the agents to be regular agents
Makes visual space for the elite agent to be represented in the world by moving all of the networked agents slightly toward the bottom of the world
Creates an elite agent separately from the networked agents and initializes the elite agent's rumors-heard? to have a single random rumor set to true
Sets up the patch coloring for the distribution of elite exposure based on the variant
Resets the ticks

The go procedure executes the following steps to execute agent behaviors:

Stop the model execution if either the number of ticks has exceeded ticks-to-end or if there are no turtles left who have not heard all of the possible rumors (i.e. full saturation of rumor disperal)
Optionally slow down the model execution with a fine-grained speed control based on model-rate-1-nth
Ask each audience agent (regulars and influencers) to do the following behaviors:
- Attempt to adopt an unheard rumor from the elites
- Attempt to adopt an unheard rumor from its neighbors in the social network
- Attempt to randomly generate a new rumor
- Attempt to randomly forget a previously heard rumor
Ask the elite agent to attempt to adopt a rumor from one of the influencer agents
Finally, increment the tick

HOW TO USE IT

Pre-execution Controls

Use the following controls to configure how the model will be set up prior to clicking the setup button:

Population settings

num-people -- the number of audience agents in the network (not including elites)
frac-influencers -- the fraction of audience agents who are influencers (the remainder are regulars)

Network layout settings

network-type -- the type of network to generate (preferential, random, or small-world)

Preferential attachment settings

min-size -- the minimum degree of connection between nodes in the preferrential attachment network

Random network settings

network-density -- the density of the random network

Small world settings

neighborhood-size -- the number of nodes connected to each node in the small world network

Elite exposure settings

variant -- the distribution of the population exposed to top-down infuence from elite rumors (uniform, irregular, block)
initial-green-pct -- the percentage of patches that are not exposed to elite rumors

Operation Controls

Use the following controls to set up and operate the model's execution:

setup -- Click the setup button to initialize the agents, network, and patch coloration
go -- Click the go button to begin the simulation
reinitialize -- Click the reinitialize button to reset the state of the simulation without resetting the network layout, agent placement, or patch coloration
ticks-to-end -- the number of ticks before the simulation ends (if it doesn't end earlier due to total rumor dispersal)
model-rate-1-nth -- slow down the model execution by 1 / n number of ticks, as a further refinement of the model speed slider

Model Parameter Controls

Use the following controls to adjust behavior of agents within the simulation. It can be useful to run the simulation by clicking go, adjust some of these sliders, and click reinitialize and then go again to see how the settings influence the behavior using an identical network layout:

Influence rate settings

elite-influence_ -- the chance for agents to be influenced by top-down elite rumor dissemination
social-influence -- the chance for agents to be influenced by adopt rumors from other agents in the network
trade-up-influence -- the chance for an influencer agent to "trade-up" a novel rumor to the elites

Rumor generation settings

rumor-generation -- the chance for an agent to spontaneously generate a new rumor during a tick
max-rumors -- the maximum number of different rumors that can be spread through the network; used to initialize the bitstring of rumors-heard?
heard-rumors-to-generate -- deterimines whether an agent must have already heard at least one rumor before they can generate any new rumors
influencers-generate-rumors -- determines whether influencer agents can generate rumors in addition to regulars (who always generate rumors)
only-one-generates -- determines whether only a single agent has a chance of generating a rumor in one tick, or if all agents have a chance in one tick

Rumor dissipation

dissipation-rate -- The chance that agents will "forget" a rumor during a tick
only-one-forgets -- determines whether only a single agent has a chance of forgetting a rumor in one tick, or if all agents have a chanced in one tick

Model Outputs

The following outputs are used to visualize dynamics of the model's behavior:

Rumor counts -- A histogram showing each of the unique rumors on the x axis and the count of how many agents have heard that specific rumor on the y axis. This is useful for visualizing the state of rumor generation and understanding the dynamics of when a rumor "catches on" in the network.
Rumors heard -- A line chart showing the average amount of the fraction of total rumors that have been heard by each agent over time, compared to the count of times that a new rumor is successfully traded up to elites. This is useful for visualizing the relationship between when an elite adopts a traded-up rumor, and how the audience network begins to adopt that rumor once it starts getting echoed back by the elites.
Rumor generation -- A line chart showing the count of times that a new rumor is created. This is useful to see the rate of rumor generation as the baseline dynamic that drives new rumor adoption and the overall count of rumors heard.
Rumor source -- A line chart showing the relative adoption rate of audience agents for whether they adopted a rumor from an elite or from the social network. This is also compared to the chart of agents who have not yet adopted any rumors.

THINGS TO NOTICE

It is easier to see some of the interesting behavior when you slow the model down.

As elites adopt traded-up rumors and echo them back to the audiences, you can see staggered "regimes" of mass rumor adoption that quickly spread across the entire network. A newly generated rumor might be slowly passed around the social network, but as soon as it is picked up and echoed back by the elites it gets disperesed quickly and totally to all of the elite-exposed agents. You can visually see this occur in the world, and by looking at the "Rumors heard" line chart.

When rumor dissipation is turned on, rumors in the social network fluctuate without settling into a pattern of total rumor adoption. However for audience agents who have exposure to elite influence, the repeated broadcasting of new and old rumors constantly reinforces the "frame" of rumors and counteracts the ongoing dissipation of rumors. You can visually see this in the world by comparing the color of agents with and without elite exposure.

Sometimes specific rumors don't catch on. Either they fail to get randomly generated, or they aren't traded up, or they are forgotten. It is possible that in a given execution, only a handful of the total rumors catch on and reach full information disperal, while other times all of the rumors will eventually get fully adopted. Note: It is not yet clear why this happens. It is possible that this is an artifact of the rumor creation procedure instead of being a meaningful model dyname. More testing and instrumentation is needed to better understand the behavior.

Without rumor dissipation, the model is essentially a runaway reinforcing feedback loop. It still demonstrates interesting patterns like staggered regimes, but having a countervailing stabilizing feedback loops makes the overall system dynamics more interesting.

THINGS TO TRY

Try setting up the model with different variants of elite exposure distribution and noting the effect this has on rumor adoption.

Try changing the relative balances of elite-influence, social-influence, trade-up-influence, and rumor-generation and seeing what effect this has on adoption and dispersal through the whole network.

Try turning rumor dissipation-rate down to zero or up really high. How much adoption influence is necessary for the amplifying feedback loop of accumulating influence to continue dominating the stabilizing loop of rumor dissipation?

EXTENDING THE MODEL

This model could be extended in a number of ways:

We could expliclitly model the process by which newly generated rumors are "traded up" to elite agents instead of this occurring automatically outside of the social network. We could also include the elies as part of the network itself instead of leaving them solely as a disconnected media influence.

Influencers themselves could be modeled in a manner that more closely resembles real-world patterns of social network influence. For example the set of agents that are selected to be influencers could be weighted to be drawn from the top end of the set of agents with a higher degree of connectivity within the network. Additionally we don't model influencers as having any particular influence within the context of social network adoption, but real-world influencers would certainly have more peer-to-peer influence.

The rumor generation process itself is pretty naive and not informed by any real world understanding of participatory rumors and conspiracy theories (e.g. Mike Caulfield's concept of "trope-field fit"). We could more explicitly model how rumors are created relative to events and ongoing narratives.

NETLOGO FEATURES

This model makes use of the NetLogo network extension to simulate the social network connection between audience agents.

The model also makes significant use of the third-party NetLogo bitstring extension in order to model rumor adoption. See the netlogo-bitstring documentation for more details on how this extension works.

RELATED MODELS

This model draws from and builds on foundational mechanics for simulating information dispersal in a network from two other models from the Modeling Commons:

The Spread of a Meme Across a Social Network by Kristen Amaddio
Correcting Information - delay and media effects by Kjirste Morrell

CREDITS AND REFERENCES

Rand, W. Introduction to Agent-Based Modeling (Summer 2017) Unit 4, Model. https://s3.amazonaws.com/complexityexplorer/ABMwithNetLogo/model-7.nlogo 7:Influentials.

Starbird, K., et al. (2021) ["What is participatory disinformation?"](https://www.cip.uw.edu/2021/05/26/participatory-disinformation-kate-starbird/ ). Center for an Informed Public, University of Washington, Seattle, WA.

Wilensky, U. (2005). NetLogo Preferential Attachment model. http://ccl.northwestern.edu/netlogo/models/PreferentialAttachment. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.

Wilensky, U. (1999). NetLogo. http://ccl.northwestern.edu/netlogo/. Center for Connected Learning and Computer-Based Modeling, Northwestern Institute on Complex Systems, Northwestern University, Evanston, IL.

COPYRIGHT AND LICENSE

This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/3.0/ or send a letter to Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.

This model was submitted as a student project for the Intro to Agent-Based Modeling class, summer 2021, offered by Santa Fe Institute and taught by William Rand.

Comments and Questions

Please start the discussion about this model! (You'll first need to log in.)

Click to Run Model

extensions [ nw bitstring ]

;; # Interface controls

;; ## Population controls
;; num-people -- the number of agents in the network (not including elites)
;; frac-influencers -- the fraction of agents who are influencers

;; ## Network controls
;; network-type -- the type of network to generate (preferential, random, or small-world)
;; ### Preferential attachment settings
;; min-size -- the minimum degree of connection between nodes in the preferrential attachment network
;; ### Random network settings
;; network-density -- the density of the random network
;; ### Small world settings
;; neighborhood-size -- the number of nodes connected to each node in the small world network

;; ## Elite exposure
;; variant -- the distribution of the population exposed to top-down infuence from elite rumors (uniform, irregular, block)
;; initial-green-pct -- the percentage of patches that are not exposed to elite rumors

;; ## Operation
;; ticks-to-end -- the number of ticks before the simulation ends (if it doesn't end earlier due to total rumor dissemination)
;; model-rate-1-nth -- slow down the model execution by 1 / n number of ticks, as a further refinement of the model speed slider

;; ## Influence rates
;; elite-influence -- the chance for agents to be influenced by top-down elite rumor dissemination
;; social-influence -- the chance for agents to be influenced by adopt rumors from other agents in the network
;; trade-up-influence -- the chance for an influencer agent to "trade-up" a novel rumor to the elites

;; # Rumor generation
;; rumor-generation -- the chance for an agent to spontaneously generate a new rumor during a tick
;; max-rumors -- the maximum number of different rumors that can be spread through the network; used to initialize the bitstring of rumors-heard?
;; heard-rumors-to-generate -- deterimines whether an agent must have already heard at least one rumor before they can generate any new rumors
;; influencers-generate-rumors -- determines whether influencer agents can generate rumors in addition to regulars (who always generate rumors)
;; only-one-generates -- determines whether only a single agent has a chance of generating a rumor in one tick, or if all agents have a chance in one tick

;; # Rumor dissipation
;; dissipation-rate -- The chance that agents will "forget" a rumor during a tick
;; only-one-forgets -- determines whether only a single agent has a chance of forgetting a rumor in one tick, or if all agents have a chanced in one tick

globals [
  times-heard-from-elites
  times-heard-from-social
  times-traded-up
  times-created-rumor
]

patches-own [
  vote
  total
]

turtles-own [
  rumors-heard?
]

breed [ regulars regular ]
breed [ influencers influencer ]
breed [ elites elite ]

to setup
  clear-all

  set-default-shape regulars "person"
  set-default-shape influencers "star"
  set-default-shape elites "pentagon"

  ;; Create the social network and audience agents
  setup-network

  ;; Randomly select frac-influencers % of audience agents to be influencers
  ask n-of ( frac-influencers * num-people ) turtles [
    set breed influencers
    set size 2
  ]

  ;; Set the rest of the audience agents as regulars
  ask turtles [
    if breed != influencers [
      set breed regulars
    ]
  ]

  ;; Create elites separately from the network of other agents

  ;; Fist make room for the elites to be represented above the rest of the network
  ask turtles [
    facexy xcor min-pycor
    fd 4
  ]

  ;; Create a single elite agent at the top of the world
  create-elites 1 [
    setxy 0 max-pycor - 1
    set size 3
    initialize-elite
   ]

  ;; Set up the distribution of elite exposure
  if variant = "uniform" [
   setup-elite-uniform
  ]
  if variant = "block" [
    setup-elite-block
  ]
  if variant = "irregular" [
    setup-elite-irregular
  ]

  reset-ticks
end 

;; Set up the social network based on the selected network-type

to setup-network
  if network-type = "preferential" [
    nw:generate-preferential-attachment turtles links num-people min-size [
      setxy random-xcor random-ycor
      initialize-agent
    ]

    let factor sqrt count turtles
    repeat 300 [
      layout-spring turtles links (1 / factor) (7 / factor) (1 / factor)
    ]
  ]

  if network-type = "random" [
    nw:generate-random turtles links num-people network-density [
      setxy random-xcor random-ycor
      initialize-agent
    ]

    repeat 30 [ layout-spring turtles links 0.3 (world-width / 2 ) 1 ]
  ]

  if network-type = "small-world" [
    nw:generate-watts-strogatz turtles links num-people neighborhood-size 0.1 [
      setxy random-xcor random-ycor
      initialize-agent
    ]

    repeat 300 [
      layout-spring turtles links 0.3 (world-width / 3) 3
    ]
  ]
end 

;; Initialize an individual "normal" (regular or influencer) agent

to initialize-agent
  set color white
  ;; initialize a bitstring representing which rumors the agent has heard, with all being false
  set rumors-heard? bitstring:make max-rumors false
end 

;; Initialize an elite agent

to initialize-elite
  ;; Initialize elites with a single random rumor to start with
  let set-rumor random (max-rumors)
  set rumors-heard? bitstring:make max-rumors false
  set rumors-heard? bitstring:set rumors-heard? set-rumor true
  set color scale-color red bitstring:count1 rumors-heard? max-rumors 0
end 

;; Reset the results of the simulation while keeping the same network and elite exposure layout

to reinitialize
  ask turtles [
    initialize-agent
  ]

  ask elites [
    initialize-elite
  ]

  clear-all-plots

  set times-heard-from-elites 0
  set times-heard-from-social 0
  set times-traded-up 0
  set times-created-rumor 0

  reset-ticks
end 

;; Elite exposure - setup by coloring patches
;; Color all of the patches uniformly
;; This is just for effect

to setup-elite-uniform
  ask patches [
    set vote 1
    recolor-patch
  ]
end 

;; Elite exposure - setup by coloring patches
;; This version just colors a contiguous block of patches

to setup-elite-block
  ;; Setup elite exposure in two blocks
  ;; Base green portion on height of world
  let green-y% (max-pycor - (world-height * initial-green-pct / 100))

  ;; Upper part of world set to green
  ask patches [
    ifelse pycor > green-y%
      [ set vote 0 ]
      [ set vote 1 ]
    recolor-patch
  ]
end 

;; This is from Voting Sensitivity Analysis, but not
;; doing exactly the same and not giving all the options
;; for different types of voting.

to setup-elite-irregular
  ;; First, set all the patches to something
  ask patches [
    ifelse random 100 < initial-green-pct
      [ set vote 0 ]
      [ set vote 1 ]
    recolor-patch
  ]
  ;; Want to set the elite exposure before start,
  ;; so loop through a few times here
  ;; alternatively, could do until no votes changed.
  ;; just in case, add a counter and a stop count
  let stop-count 100
  let counter 0
  loop [
    let any-votes-changed? FALSE
    ;; Patches total votes of neighbors
    ask patches [
      set total (sum [ vote ] of neighbors )
    ]
    ; Patches set votes based on neighbors
    ask patches [
      let previous-vote vote
      if total < 3 [ set vote 0 ] ;; if majority of your neighbors vote 0, set your vote to 0
      if total = 3 [
        set vote 0
      ]
      if total = 4  [
        set vote (1 - vote) ;; invert the vote if tied
      ]
      if total = 5 [
        set vote 1
      ]
      if total > 5 [ set vote 1 ] ;; if majority of your neighbors vote 1, set your vote to 1
      if vote != previous-vote [ set any-votes-changed? true ]
      recolor-patch
    ]
    set counter counter + 1
    ; Check if end conditions reached
    if not any-votes-changed? or counter = stop-count [ stop ]
  ]
end 

;; Patch coloring procedure

to recolor-patch
  ifelse vote = 0
    [ set pcolor 58 ]   ; light green to avoid conflicting with turtle colors
    [ set pcolor 28 ]   ; light orange - avoiding blues and reds
end 

;; Runs the simulation

to go
  ;; End the simulation when either the number of ticks exceeds ticks-to-end or there are no turtles left who haven't heard all of the rumors
  if ( ticks >= ticks-to-end or not any? turtles with [ bitstring:any0? rumors-heard? ] ) [
    stop
  ]

  ;; Fine-grained control of the model speed beyond that offered by the tick speed, in case we want to observe nuanced behavior
  if ( ticks mod model-rate-1-nth = 0 ) [

    ;; Agents attempt to adopt rumors from elites, adopt rumors from the social network, generate new rumors, or forget rumors
    ask turtles with [ not (breed = elites) ] [
      adopt-from-elites
      adopt-from-network

      ;; For performance optimization we try to do all of our processing inside of a single loop of the full agentset.
      ;; Becuase we have parameters that let us selectively apply processing to only a single agent per tick, we use the idiom
      ;; `if (random num-people = who)` instead of `ask one-of turtles`. This lets us  apply these behaviors to either the
      ;; full agentset or a single agent without potentially looping through the agentset multiple times in a single tick.

      if (not only-one-generates or random num-people = who) [
        if (breed != influencers or influencers-generate-rumors) [
          generate-rumors
        ]
      ]

      if (not only-one-forgets or random num-people = who) [
        forget-rumors
      ]
    ]

    ;; Elites attempt to adopt a traded-up rumor
    trade-up-rumors
  ]

  tick
end 

;; Agent attempts to adopt an unheard rumor from exposure to the elites, based on its distribution of exposure

to adopt-from-elites
  let elite-rumors [rumors-heard?] of one-of elites
  let elite-adoption elite-influence

  if variant = "irregular" or variant = "block" [
    ;; In this version, elite-influence environment is different depending on patch
    ;; Patch color green (58) corresponds to corrective influence,
    ;; patch color orange (28) corresponds to adoptive influence
    let near-adopt-pct (count neighbors with [ pcolor = 28 ] / 8 )
    let own-adopt 0
    ifelse pcolor = 28
      [ set own-adopt 1 ]
    [ set own-adopt 0 ]
    set elite-adoption ( elite-influence * 0.5 * (near-adopt-pct + own-adopt ) )
  ]

  if (random-float 1.0 < elite-adoption) [
    set rumors-heard? adopt-rumor rumors-heard? elite-rumors
    set times-heard-from-elites times-heard-from-elites + 1
    set color scale-color red bitstring:count1 rumors-heard? max-rumors 0
  ]
end 

;; Agent attempts to adopt an unheard rumor from the social network, based on the fraction of neighbors who have already adopted any rumors

to adopt-from-network
  ;; Neighbors who have adopted any rumors have an influence on the chance of adoption
  let neighbors-adopted link-neighbors with [ any-rumors ]
  let total-neighbors link-neighbors

  ;; Randomly select one of the neighbors who have adopted any rumor to be the source of the rumor that will be adopted
  let rumor-source one-of neighbors-adopted

  if count total-neighbors > 0 and random-float 1.0 < ( social-influence * count neighbors-adopted / count total-neighbors ) [
    set rumors-heard? adopt-rumor rumors-heard? [rumors-heard?] of rumor-source
    set times-heard-from-social times-heard-from-social + 1
    set color scale-color red bitstring:count1 rumors-heard? max-rumors 0
  ]
end 

;; Agent attempts to generate a new rumor

to generate-rumors
  ;; Only attempt to generate a rumor if we've already heard any rumors or if that requirement is disabled
  if (not heard-rumors-to-generate or not bitstring:all0? rumors-heard? ) [

    if (random-float 1.0 < rumor-generation) [
      ;; Create a new rumor pattern
      let new-rumors create-rumor rumors-heard?
      ;; Only increment the counter if we actually created a new rumor instead of setting an existing rumor
      if ( not (rumors-heard? bitstring:contains? new-rumors )) [
        set rumors-heard? new-rumors
        set times-created-rumor times-created-rumor + 1
      ]
    ]
  ]
end 

;; Agent attempts to forget a rumor that it's already heard

to forget-rumors
  if ( random-float 1.0 < dissipation-rate ) [
    set rumors-heard? forget-rumor rumors-heard?
  ]
end 

;; The elite agents will attempt to learn a rumor that is being traded-up by one of the influencer agents.

to trade-up-rumors
  ;; Elites will listen to a random influencer and attempt to adopt one of the unheard rumors
  if (count influencers > 0 and random-float 1.0 < trade-up-influence) [
    let one-influencer one-of influencers
    let influencer-rumors [rumors-heard?] of one-influencer
    ask elites [
      let new-rumors adopt-rumor rumors-heard? influencer-rumors
      ;; Adopt the set of rumors if we've never heard it before
      if ( not ( rumors-heard? bitstring:contains? new-rumors )) [
        set rumors-heard? new-rumors
        set color scale-color red bitstring:count1 rumors-heard? max-rumors 0
        set times-traded-up times-traded-up + 1
      ]
    ]
  ]
end 

;; Utility procedure to adopt a single new rumor that the agent hasn't heard before, if there are any.
;; Reports a new bitstring of rumors with the first novel rumor adopted, or the original bitstring.
;; If there are > 1 novel rumors, only adopt the first one.

to-report adopt-rumor [my-rumors other-rumors]
  ;; Set a series of masks to identify only the bit positions that contain an unheard rumor
  let mask my-rumors bitstring:or other-rumors
  let novel-rumors my-rumors bitstring:xor mask

  ;; Only adopt a rumor if there are any novel rumors, or else return the original rumors
  ifelse (bitstring:count1 novel-rumors > 0) [
    ;; deterimine the position of the first novel rumor in the bitstring
    let pos 0
    while [ not bitstring:first? novel-rumors ] [
      ;; Drop the first bit because it wasn't novel and increment the index
      set novel-rumors bitstring:but-first novel-rumors
      set pos pos + 1
    ]
    report bitstring:set my-rumors pos true
  ]
  [
    report my-rumors
  ]
end 

;; Utility procedure to create a random rumor by setting a random bit to true. It might be a rumor that we already heard before.

to-report create-rumor [my-rumors]
  let pos random max-rumors
  report bitstring:set my-rumors pos true
end 

;; Utility procedure that attempts to forget a rumor by setting a random bit to false. It might be a rumor that we never heard in the first place.

to-report forget-rumor [my-rumors]
  let pos random max-rumors
  report bitstring:set my-rumors pos false
end 

;; Report if the agent has heard any rumors

to-report any-rumors
  report bitstring:count1 rumors-heard? > 0
end 

;; Report the fraction of total rumors heard by the agent

to-report frac-rumors
  report bitstring:count1 rumors-heard? / max-rumors
end 

;; Reports a list of all of the indexes of specific rumors that have been heard by turtles, for plotting on a histogram

to-report rumor-counts
  report reduce sentence [ map-rumors-to-positions rumors-heard? ] of turtles
end 

;; Utility procedure to map the rumors to their positions, for plotting on a histogram

to-report map-rumors-to-positions [rumors]
  report (map [ [ rumor index ] -> ifelse-value rumor [index + 1] [0] ]
    bitstring:to-list rumors (n-values max-rumors [ i -> i] ) )
end

There is only one version of this model, created almost 3 years ago by Scott P. Johnson.

Attached files

File	Type	Description	Last updated
Participatory Disinformation.png	preview	Preview for 'Participatory Disinformation'	almost 3 years ago, by Scott P. Johnson	Download

This model does not have any ancestors.

This model does not have any descendants.

NetLogo