Analyze intermittent resilience–stress correlation due to multi-factor mediation dynamics

[lamurian]

User Story

As a researcher, I want to understand why the correlation between resilience and stress fluctuates between weak and moderate levels despite correct model implementation, so that I can determine whether this reflects true system behavior or a configuration issue.

Description

The observed intermittent non-significant correlation between resilience and stress, even after fixing data collection, arises from the model’s complex multi-factor dynamics. These dynamics generate indirect (mediated) rather than direct relationships, leading to temporal variation in correlation strength.

Root Cause: Complex Mediation Effects

The model correctly encodes the theoretical expectation — higher resilience → better coping → lower stress — but multiple mechanisms dilute this direct link:

1. Multiple Resilience Drivers (Independent of Stress)

   • Social support boosts resilience independently of stress events (agent.py, lines 284–285, 319–328)
   • Protective factor rewards increase resilience post-success (agent.py, lines 297–303)
   • Resource regeneration amplifies resilience via affect multipliers (agent.py, lines 305–317)

2. PSS-10 Feedback Loop Attenuation

   • Exponential smoothing stabilizes stress changes (agent.py, lines 767–773)
   • Daily averaging of PSS-10 scores introduces lag (agent.py, lines 377–384)
   • Stress dimensions update from both event outcomes and PSS-10 feedback (agent.py, line 647)

3. Homeostatic Homogenization

   • Daily baseline correction pulls variables toward fixed set points (agent.py, lines 336–372)
   • Homeostatic scaling with resource and stress rates (agent.py, lines 345–356)
   • Population convergence reduces inter-agent variability

4. Timing and State Dependencies

   • Stress decays after data collection (agent.py, lines 817–821)
   • Event-driven resilience updates occur asynchronously with social boosts
   • PSS-10 accumulation causes delayed influence on stress levels

Why Correlation Varies

• Moderate negative correlation appears during active stress processing phases.
• Weak or non-significant correlation appears during equilibrium or post-stress states.
• Population-level averaging further attenuates correlation due to heterogeneity in agent trajectories.

Theoretical Alignment

This behavior is theoretically consistent: real-world resilience–stress dynamics are mediated by multiple interdependent factors rather than direct bivariate associations. The model accurately represents these complex psychological interactions.

Proposed Flow

• Verify correlation coefficients across time windows (event phase vs. equilibrium)
• Visualize time-lagged correlations to confirm mediation effects
• Document findings in docs/analysis/resilience_stress_mediation.md
• Confirm .env parameters for smoothing and baseline rates align with intended dynamics

Reference

• agent.py (lines 284–821): Agent behavior, feedback loops, and homeostatic mechanisms
• .env configuration: Smoothing, baseline, and decay parameters

Notes:

• No structural changes required; this is a valid emergent model behavior.
• Recommend emphasizing context-dependent correlation in documentation.
• Consider reporting both instantaneous and time-lagged correlation analyses for interpretability.

[lamurian]

Bootstrapping might be an excellent approach for this agent-based model to obtain more confident correlation estimates, given the stochastic nature and complex dynamics. Here's a comprehensive analysis of bootstrapping and alternative approaches:

Bootstrapping Implementation

Why Bootstrapping Works Here

• Stochastic variability: Each simulation run produces different outcomes due to random seeds, network initialization, and event sequences
• Complex dynamics: The resilience-stress relationship is mediated by multiple factors, creating non-stationary correlations
• Sample size limitations: With 30 agents, individual correlations have high uncertainty

Implementation Strategy

def bootstrap_correlations(n_bootstraps=100, n_agents=30, n_days=100, seed_base=42):
    """Run multiple simulations to bootstrap correlation estimates."""
    correlations = []
    
    for i in range(n_bootstraps):
        # Use different seed for each bootstrap sample
        seed = seed_base + i
        
        # Run simulation
        model = StressModel(N=n_agents, max_days=n_days, seed=seed)
        while model.running:
            model.step()
        
        # Extract final agent data
        agent_data = model.get_agent_time_series_data()
        final_data = agent_data[agent_data['Step'] == agent_data['Step'].max()]
        
        # Calculate correlation
        corr = final_data['resilience'].corr(final_data['current_stress'])
        correlations.append(corr)
    
    return correlations

# Usage
correlations = bootstrap_correlations(n_bootstraps=500)
mean_corr = np.mean(correlations)
ci_lower, ci_upper = np.percentile(correlations, [2.5, 97.5])

Benefits

• Confidence intervals: Quantify uncertainty in correlation estimates
• Robustness testing: Identify when correlations are consistently significant vs. variable
• Power analysis: Determine required sample sizes for stable estimates

Alternative Approaches

1. Parameter Sensitivity Analysis

def parameter_sweep_correlations(param_ranges, n_replicates=50):
    """Test correlation stability across parameter space."""
    results = []
    
    for params in generate_parameter_combinations(param_ranges):
        correlations = []
        for rep in range(n_replicates):
            model = StressModel(**params, seed=rep)
            # Run and collect correlation
            correlations.append(run_and_get_correlation(model))
        
        results.append({
            'params': params,
            'mean_corr': np.mean(correlations),
            'corr_std': np.std(correlations),
            'significant_rate': sum(abs(c) > 0.3 for c in correlations) / n_replicates
        })
    
    return results

2. Time-Series Correlation Analysis

def analyze_temporal_correlations(model_data):
    """Examine how correlations evolve over simulation time."""
    correlations_over_time = []
    
    for day in range(1, len(model_data)):
        # Use agent data up to current day
        agent_data = model.get_agent_time_series_data()
        current_data = agent_data[agent_data['Step'] <= day]
        
        # Calculate correlation for each agent trajectory
        agent_corrs = []
        for agent_id in current_data['AgentID'].unique():
            agent_subset = current_data[current_data['AgentID'] == agent_id]
            if len(agent_subset) > 1:
                corr = agent_subset['resilience'].corr(agent_subset['current_stress'])
                agent_corrs.append(corr)
        
        correlations_over_time.append({
            'day': day,
            'mean_agent_corr': np.mean(agent_corrs),
            'corr_stability': np.std(agent_corrs)
        })
    
    return correlations_over_time

3. Cross-Sectional vs. Longitudinal Analysis

• Cross-sectional: Single time point correlations (current approach)
• Longitudinal: Within-agent correlations over time
• Panel analysis: Mixed effects models accounting for both

4. Network-Based Correlation Analysis

def network_correlation_analysis(model):
    """Analyze correlations within network neighborhoods."""
    neighborhood_correlations = []
    
    for agent in model.agents:
        neighbors = list(model.grid.get_neighbors(agent.pos, include_center=False))
        if len(neighbors) >= 3:  # Minimum for correlation
            neighbor_data = pd.DataFrame([{
                'resilience': n.resilience,
                'stress': n.current_stress
            } for n in neighbors + [agent]])
            
            corr = neighbor_data['resilience'].corr(neighbor_data['stress'])
            neighborhood_correlations.append(corr)
    
    return neighborhood_correlations

5. Model Validation Approaches

• Pattern matching: Compare simulated correlations against empirical literature targets
• Approximate Bayesian Computation: Use correlation strength as validation metric
• Synthetic data comparison: Generate known-correlation datasets for validation

6. Statistical Alternatives

• Partial correlations: Control for mediating variables (affect, resources, PSS-10)
• Structural equation modeling: Test theoretical pathways
• Non-parametric tests: Spearman correlations for robustness
• Bayesian correlation estimation: Incorporate prior knowledge

Recommended Implementation Priority

1. Bootstrapping (immediate): Provides confidence intervals for current correlation estimates
2. Time-series analysis (short-term): Reveals when correlations are strongest/weakest
3. Parameter sensitivity (medium-term): Identifies conditions producing significant correlations
4. Network analysis (long-term): Tests if correlations vary by social context

Implementation Considerations

• Computational cost: Bootstrapping 500 simulations with 30 agents × 100 days requires significant compute time
• Parallelization: Use multiprocessing for bootstrap samples
• Storage: Save correlation distributions for meta-analysis
• Statistical power: Ensure adequate bootstrap samples (minimum 200-500) for stable confidence intervals