## 4 Methodology
### Information Diffusion Simulation  
We implemented a comprehensive information diffusion model based on population dynamics with a time delay. This model simulates how information spreads through a network with specific delay mechanisms between exposure and propagation. The diffusion process begins with seed nodes that initially possess the information. If no seed nodes are specified, the algorithm selects a high-degree node as the starting point. Each node maintains two important time markers: activation time (when it receives information) and spreading time (when it begins sharing information). The core simulation mechanism (Algorithm 1) works as follows:  
1. At each time step, nodes that have reached their spreading time attempt to transmit information to their neighbors. 2. Transmission succeeds with probability p_spread. 3. Upon successful transmission, the neighbor node is activated. 4. The newly activated node experiences a delay before it can spread information further. 5. The delay duration depends on the specified delay mechanism. We implemented three distinct delay mechanisms to model different information sharing behaviors:  
1. Constant delay--Every node experiences the same fixed delay (delay_param);
2. Uniform delay--Delay is randomly selected from uniform distribution [1, delay_param];
3. Exponential delay--Delay follows an exponential distribution with mean delay_param. For each simulation, we recorded several outcome metrics:  
* Coverage (fraction of nodes that received information);
* Peak diffusion speed (maximum rate of new activations);
* Time to reach peak speed;
* Time to half coverage (when 50% of nodes are activated);
* Full activation history over time. ```
1:Input: Graph G, seed_nodes (optional), p_spread, max_steps, delay_type, delay_param Output: Diffusion results (coverage, temporal dynamics)
2:1:// Initialize with seed nodes
3:if seed_nodes is None then
4:degrees \(\leftarrow\) Calculate node degrees in G
5:candidate_nodes \(\leftarrow\) Sort nodes by degree (descending)
6:seed_nodes \(\leftarrow\) Randomly select one high-degree node
7:
8:// Initialize tracking dictionaries
9:activation_times \(\leftarrow\) {node: \(\infty\) for all nodes in G}
10:spreading_times \(\leftarrow\) {node: \(\infty\) for all nodes in G}
11:for seed in seed_nodes do
12:activation_times[seed] \(\leftarrow\) 0
13:spreading_times[seed] \(\leftarrow\) 0
14:end for
15:
16:// Run diffusion simulation
17:active_nodes \(\leftarrow\) seed_nodes
18:current_step \(\leftarrow\) 0
19:history \(\leftarrow\) {}
20:while current_step < max_steps AND active_nodes not empty do
21:new_activations \(\leftarrow\) {}
22:for node in active_nodes do
23:if spreading_times[node] \(\leq\) current_step then
24:for neighbor in G.neighbors(node) do
25:if activation_times[neighbor] = \(\infty\) AND random() < p_spread then
26:activation_times[neighbor] \(\leftarrow\) current_step
27:// Calculate delay based on specified mechanism
28:if delay_type = \"constant\" then
29:delay \(\leftarrow\) delay_param
30:else if delay_type = \"uniform\" then
31:delay \(\leftarrow\) random_uniform(1, delay_param)
32:else if delay_type = \"exponential\" then
33:delay \(\leftarrow\) random_exponential(delay_param)
34:endif
35:spreading_times[neighbor] \(\leftarrow\) current_step + delay
36:new_activations.add(neighbor)
37:endif
38:end for
39:endif
40:end for
41:active_nodes.update(new_activations)
42:history[current_step] \(\leftarrow\) count nodes with activation_time \(\leq\) current_step
43:current_step \(\leftarrow\) current_step + 1
44:end while
45:
```  
**Algorithm 1**Information diffusion with delay  
```
46://Calculate metrics
47:coverage\(\leftarrow\) proportion of nodes with finite activation_time
48:active_counts\(\leftarrow\) differences between consecutive history values
49:peak_speed\(\leftarrow\) maximum value in active_counts
50:peak_speed_time\(\leftarrow\) time step of peak_speed
51:
52:return coverage, peak_speed, peak_speed_time, history
```  
**Algorithm 1**Cont. We ran extensive simulations on both real and synthetic networks.