Modeling Complex Behavior Spread in Vee Networks

From Simple Exposure to Social Reinforcement

The key difference between simple and complex contagion lies in the adoption mechanism. While simple contagion is probabilistic after a single exposure, complex contagion is often modeled as a deterministic process based on a threshold. An individual adopts a new behavior only when a certain number or proportion of their social contacts have already adopted it.

This idea was famously formalized by sociologist Mark Granovetter. His work provides a powerful lens for understanding collective behavior, from riots to the diffusion of innovations. Given your background in decision theory, you'll find the core concept quite intuitive: the threshold represents the point at which the perceived benefits of adopting a behavior (e.g., from conforming, coordination, or social proof) finally outweigh the perceived costs or risks.

The Linear Threshold Model on a Network

Granovetter's original model considered individuals observing the entire population. Duncan Watts later adapted this to networks, where individuals only observe their immediate neighbors. This is called the Linear Threshold Model, and it's what we will implement.

The rule is simple: An individual i with k_i neighbors (a degree of k_i) has a personal threshold φ_i (a value between 0 and 1). They will adopt the new behavior (e.g., agree to the new rule) if the proportion of their neighbors who have already adopted it is greater than or equal to their threshold.

Adoption condition for node i: (Number of active neighbors) / k_i >= φ_i

This model is deterministic. Once the condition is met, adoption is certain. It's a "complex" contagion because if an individual has, for instance, a threshold of φ = 0.6 and four neighbors, they need at least 0.6 * 4 = 2.4, meaning 3 neighbors, to adopt before they do. One is not enough.

The following presentation slides provide a concise summary of how this model operates on a network.

Simulating a New Rule Adoption in a Vee

Let's model a scenario where one person in a vee wants to introduce a new relationship rule, such as "We should schedule our dates at least one week in advance." This is a complex behavior because it requires coordination and buy-in. We'll use the same NetworkX vee structure from our last lesson.

Step 1: Set up the Network and Thresholds

The network is the same: Hinge (H), Partner 1 (P1), and Partner 2 (P2). The key new element is assigning a threshold to each person. This value represents their resistance or need for social proof. A low threshold means they are an "early adopter," while a high threshold means they are more skeptical or cautious.

import networkx as nx




# Create the vee network
G = nx.Graph()
nodes = ["H", "P1", "P2"]
G.add_nodes_from(nodes)
edges = [("H", "P1"), ("H", "P2")]
G.add_edges_from(edges)




# Assign degrees to each node for later use
for node in G.nodes():
    G.nodes[node]['degree'] = G.degree(node)

Step 2: Define the Threshold Simulation Logic

Our simulation function will take the graph, a set of thresholds, and the initial "seed" adopters. It will run in discrete time steps. In each step, it checks all inactive nodes to see if their threshold condition is met based on the state of their neighbors from the previous step.

def threshold_model(graph, thresholds, seed_nodes, max_steps=5):
    """
    Simulates the Linear Threshold model.
    
    Returns a list of sets, where each set contains the active nodes at that time step.
    """
    active_nodes_over_time = []
    



    # Step 0: Initial state
    active_set = set(seed_nodes)
    active_nodes_over_time.append(active_set.copy())
    
    for i in range(max_steps):
        newly_activated = set()
        



        # Check every inactive node
        for node in graph.nodes():
            if node not in active_set:



                # Count how many neighbors are active
                active_neighbors = 0
                for neighbor in graph.neighbors(node):
                    if neighbor in active_set:
                        active_neighbors += 1
                



                # Check if the threshold condition is met
                k_i = graph.nodes[node]['degree']
                phi_i = thresholds[node]
                if k_i > 0 and (active_neighbors / k_i) >= phi_i:
                    newly_activated.add(node)
        



        # If no new nodes were activated, the cascade stops
        if not newly_activated:
            break
        



        # Add the newly activated nodes to the main active set
        active_set.update(newly_activated)
        active_nodes_over_time.append(active_set.copy())
        
    return active_nodes_over_time

Step 3: Run and Analyze Scenarios

Now for the interesting part. Let's explore how the rule spreads (or doesn't) based on who proposes it and what the thresholds are.

• Scenario A: A "Vulnerable" Hinge
  The hinge's degree is 2. The hinge is "vulnerable" if their threshold φ_H <= 1/2 = 0.5. This means the hinge can be convinced by just one of their partners. Let's see what happens.

  thresholds_A = {"H": 0.5, "P1": 0.8, "P2": 0.8}
  (The partners' thresholds are high, but since they only have one neighbor, any threshold <=1.0 means they just need the hinge to adopt.)

  • If P1 proposes the rule (is the seed):

    cascade_A1 = threshold_model(G, thresholds_A, ["P1"])
    print("Scenario A1 (P1 is seed, Hinge is vulnerable):")
    for t, active_set in enumerate(cascade_A1):
        print(f"Time {t}: {sorted(list(active_set))}")
    

    Output:

    Scenario A1 (P1 is seed, Hinge is vulnerable):
    Time 0: ['P1']
    Time 1: ['H', 'P1']
    Time 2: ['H', 'P1', 'P2']
    

    The cascade succeeds! At Time 1, H sees 1 of 2 neighbors (50%) are active. Since 0.5 >= φ_H, H adopts. At Time 2, P2 sees its only neighbor (H) is active, so P2 adopts. The new rule spreads throughout the vee.

• Scenario B: A "Resistant" Hinge
  Now, let's make the hinge require reinforcement from both partners. Their threshold φ_H must be greater than 0.5. Let's set it to 1.0, meaning they need 100% of their neighbors to act first.

  thresholds_B = {"H": 1.0, "P1": 0.8, "P2": 0.8}

  • If P1 proposes the rule:

    cascade_B1 = threshold_model(G, thresholds_B, ["P1"])
    print("\nScenario B1 (P1 is seed, Hinge is resistant):")
    for t, active_set in enumerate(cascade_B1):
        print(f"Time {t}: {sorted(list(active_set))}")
    

    Output:

    Scenario B1 (P1 is seed, Hinge is resistant):
    Time 0: ['P1']
    

    The cascade dies immediately. H sees only 1 of 2 neighbors is active (50%). Since 0.5 < φ_H, H does not adopt, and the process stalls. This demonstrates the immense gatekeeping power of a hinge who requires consensus.

  • What if the Hinge proposes the rule?

    cascade_B2 = threshold_model(G, thresholds_B, ["H"])
    print("\nScenario B2 (Hinge is seed and resistant):")
    for t, active_set in enumerate(cascade_B2):
        print(f"Time {t}: {sorted(list(active_set))}")
    

    Output:

    Scenario B2 (Hinge is seed and resistant):
    Time 0: ['H']
    Time 1: ['H', 'P1', 'P2']
    

    Here, the cascade succeeds instantly. When the hinge is the initiator, both partners see that their sole connection has adopted the rule, and they follow suit. This shows that the hinge has disproportionate power to initiate change.

The Big Picture: Structure and Contagion Type

The interplay between network structure, individual thresholds, and contagion type is summarized beautifully in the following diagram.

Our vee network is not highly clustered; it resembles a small star graph. As Panel A suggests, such structures are not ideal for spreading complex contagions that require reinforcement from multiple, independent sources. The success of a cascade in a vee therefore depends almost entirely on the hinge's threshold and who initiates the change. Our model, with its fixed thresholds, is a "Deterministic" adoption model, as shown in Panel B. The combination of a high threshold (> 1/k_i) and this deterministic rule places our model squarely in the "Deterministic Complex" or "Probabilistic Complex" regions shown in Panel C.

Conclusion

In this lesson, we have constructed a model for complex contagion, which is essential for understanding how significant changes and norms are adopted within a relationship structure.

Key Takeaways:

• Complex behaviors require social reinforcement, which can be modeled using a threshold model. An individual adopts only when a sufficient proportion of their neighbors have already done so.
• The hinge's threshold is the single most critical parameter for the spread of complex norms in a vee. A "vulnerable" hinge (threshold ≤ 0.5) allows change to propagate from one partner, while a "resistant" hinge (threshold > 0.5) acts as a gatekeeper, blocking changes that don't have consensus.
• The initiator of the change matters. A hinge-initiated change spreads easily, whereas a partner-initiated change is contingent on the hinge's threshold.
• The structure of the vee network (low clustering) makes it inherently more resistant to complex contagions compared to more densely interconnected networks (like a closed triad), amplifying the power of the hinge.

We have now explored how both simple information and complex norms diffuse across a network. In our next lesson, we will begin our final module, "Integrative Analysis: Games on Networks," where we will synthesize our knowledge of game theory and network theory. We will start by formulating a game played on the vee network, analyzing how a player's network position influences their strategic payoffs and decisions.