Free SKILL.md scraped from GitHub. Clone the repo or copy the file directly into your Claude Code skills directory.
npx versuz@latest install hiyenwong-ai-collection-collection-skills-complex-system-robustness-collapsegit clone https://github.com/hiyenwong/ai_collection.gitcp ai_collection/SKILL.MD ~/.claude/skills/hiyenwong-ai-collection-collection-skills-complex-system-robustness-collapse/SKILL.md---
name: complex-system-robustness-collapse
description: "Complex system robustness and collapse analysis - temporal structure, percolation methods, phase transitions, bistability, catastrophic collapse. Activation: system robustness, system collapse, complex network, phase transition, resilience analysis."
---
# Complex System Robustness and Collapse Analysis
A skill for analyzing robustness and collapse mechanisms in complex systems, focusing on temporal structure, network resilience, and phase transitions.
## Core Theory
### Temporal Structure in Networks
**Key Insight**: Temporal structure organizes community diversity into distinct ecological phases, creating:
- Alternative high- and low-diversity states
- Bistable regimes
- Bottlenecks that inhibit species persistence
**Mathematical Framework**:
```
Network Structure → Temporal Dynamics → Phase Space → Robustness Analysis → Collapse Prediction
```
### Percolation Methods
**Percolation Analysis** for network robustness:
1. **Node Removal**: Identify critical nodes whose removal causes network fragmentation
2. **Edge Percolation**: Analyze connectivity thresholds under edge removal
3. **Percolation Threshold**: Critical point where system transitions from connected to fragmented state
**Key Metrics**:
- Giant component size
- Percolation probability
- Critical occupation probability (pc)
### Phase Transitions and Bistability
**Catastrophic vs. Gradual Transitions**:
- **Gradual shifts**: Smooth transition between states
- **Catastrophic collapse**: Abrupt, discontinuous transition
- **Bistable regime**: System can exist in either high or low diversity state
**Phase Diagram Components**:
```
Stable State 1 (High Diversity)
↕ (Bistable Region)
Stable State 2 (Low Diversity)
→ Collapse Point (Critical Threshold)
```
## Methods
### Method 1: Temporal Network Analysis
**Steps**:
1. Construct temporal network model with seasonal turnover
2. Identify temporal bottlenecks and critical periods
3. Analyze percolation under temporal perturbations
4. Predict system fragility based on temporal structure
**Code Pattern**:
```python
def analyze_temporal_robustness(network, time_windows):
"""
Analyze robustness considering temporal structure.
Args:
network: NetworkX graph with temporal edges
time_windows: List of time periods to analyze
Returns:
robustness_metrics: Dict of robustness measures per time window
"""
results = {}
for window in time_windows:
# Extract subgraph for time window
subgraph = extract_temporal_subgraph(network, window)
# Compute percolation threshold
pc = compute_percolation_threshold(subgraph)
# Identify critical nodes
critical_nodes = find_critical_nodes(subgraph)
# Compute bistability indicators
bistability = detect_bistability(subgraph)
results[window] = {
'percolation_threshold': pc,
'critical_nodes': critical_nodes,
'bistability': bistability
}
return results
```
### Method 2: Collapse Detection
**Early Warning Signals**:
1. **Critical slowing down**: Recovery rate decreases near critical point
2. **Variance increase**: Fluctuations grow larger approaching collapse
3. **Autocorrelation increase**: Temporal correlation rises
4. **Spatial coherence**: Spatial patterns become more correlated
**Implementation**:
```python
def detect_early_warning_signals(time_series):
"""
Detect early warning signals of system collapse.
Signals:
- Critical slowing down: recovery_rate → 0
- Variance increase: var(t) → ∞ as t → tc
- Autocorrelation: lag-1 autocorrelation → 1
"""
signals = {
'variance': compute_rolling_variance(time_series),
'autocorrelation': compute_lag1_autocorrelation(time_series),
'recovery_rate': estimate_recovery_rate(time_series)
}
# Combine signals for collapse prediction
collapse_probability = predict_collapse(signals)
return collapse_probability, signals
```
### Method 3: Resilience Engineering
**Design Principles**:
1. **Redundancy**: Multiple pathways for critical functions
2. **Modularity**: Isolate failures to prevent cascade
3. **Diversity**: Multiple species/agents performing similar roles
4. **Adaptive capacity**: System can reconfigure under stress
**Resilience Framework**:
```python
def design_resilient_system(system, constraints):
"""
Design system with resilience properties.
Args:
system: Original system specification
constraints: Design constraints (budget, performance, etc.)
Returns:
resilient_design: System design with resilience metrics
"""
# Add redundancy to critical components
redundancy_design = add_redundancy(system,
critical_components=identify_critical(system),
redundancy_factor=constraints.redundancy)
# Modularize system structure
modular_design = create_modules(redundancy_design,
isolation_level=constraints.isolation)
# Ensure functional diversity
diverse_design = ensure_diversity(modular_design,
diversity_metric=constraints.diversity)
return diverse_design
```
## Applications
### Application 1: Ecological Networks
**Plant-Pollinator Networks**:
- Temporal structure creates bottlenecks during flowering seasons
- Percolation analysis identifies critical plant/pollinator species
- Bistability between diverse and collapsed states
- Early warning: pollinator decline → network fragmentation
### Application 2: Infrastructure Networks
**Power Grids, Transportation, Communication**:
- Temporal demand patterns create stress periods
- Cascading failures through percolation dynamics
- Critical nodes: hubs, control centers
- Resilience design: redundancy, distributed control
### Application 3: Social/Information Networks
**Social Media, Financial Networks**:
- Temporal attention cycles create vulnerability
- Viral cascade dynamics
- Bistability: stable vs. chaotic information flow
- Early warning: sentiment polarization, echo chamber formation
## Key Concepts
| Concept | Definition | Measurement |
|---------|-----------|-------------|
| **Robustness** | Ability to maintain function under perturbation | Giant component size after node removal |
| **Resilience** | Ability to recover from perturbation | Recovery rate, time to equilibrium |
| **Bistability** | Two stable states exist | Phase diagram, stability analysis |
| **Percolation Threshold** | Critical point for connectivity | Occupation probability pc |
| **Temporal Bottleneck** | Period of heightened vulnerability | Network density in time window |
| **Catastrophic Collapse** | Abrupt state transition | Discontinuity in state trajectory |
## Mathematical Foundations
### Percolation Theory
**Giant Component Size**:
```
P∞(p) = 0 for p < pc
P∞(p) > 0 for p ≥ pc
```
**Critical Threshold**:
```
pc = 1 / (⟨k⟩ - 1) # for random networks (Erdős–Rényi)
```
### Phase Transition Dynamics
**Order Parameter** (diversity, connectivity):
```
φ(t) → φ_high (stable)
φ(t) → φ_low (stable)
φ(t) → critical (bistable boundary)
```
**Landau Theory** (simplified):
```
F(φ) = aφ² + bφ⁴ + cφ⁶
```
- a > 0, b < 0 → bistability
- a < 0 → single stable state
### Early Warning Signals
**Critical Slowing Down**:
```
dφ/dt ≈ -λ(φ - φ*)
λ → 0 as approaching critical point
```
**Variance Scaling**:
```
σ² ∝ 1/λ → ∞ as λ → 0
```
## Design Patterns
### Pattern A: Temporal Robustness Analysis
```
Time-series Network → Percolation per Window → Identify Bottlenecks → Predict Fragility
```
### Pattern B: Collapse Early Warning
```
System State Time Series → Compute Signals (variance, autocorr, recovery) → Collapse Probability → Alert
```
### Pattern C: Resilience Design
```
Critical Components → Add Redundancy → Modularize → Ensure Diversity → Test Resilience
```
## Tools
**Python Libraries**:
- NetworkX: Network analysis, percolation
- SciPy: Phase transition analysis, stability
- Statsmodels: Time series analysis, early warning signals
- Matplotlib: Phase diagrams, robustness curves
**Analysis Pipeline**:
```python
import networkx as nx
import numpy as np
from scipy import stats
# 1. Build temporal network
G = nx.Graph()
# Add temporal edges with timestamps
# 2. Compute percolation threshold
pc = nx.percolation_threshold(G)
# 3. Identify critical nodes
critical = nx.betweenness_centrality(G)
# 4. Detect bistability
bistable_regions = analyze_stability_regions(G)
# 5. Predict collapse
collapse_risk = predict_system_collapse(G, time_window)
```
## Reference Paper
**arXiv:2604.07347v1** - "Temporal Structure Mediates the Robustness and Collapse of Plant-Pollinator Networks"
**Key Contributions**:
1. Structural model with seasonal turnover
2. Percolation methods for community analysis
3. Analytical solutions linking structure to diversity
4. Phase diagram with bistable regimes
5. Temporal bottleneck identification
## Activation Keywords
- system robustness
- system collapse
- complex network resilience
- phase transition
- bistability
- catastrophic collapse
- percolation analysis
- temporal network
- early warning signals
- resilience engineering
## Recommended Model
- **sonnet4.5** (balanced analysis)
- **opus4.5** (deep theoretical analysis)
## Related Skills
- **network-science**: General network analysis
- **system-dynamics**: Dynamic system modeling
- **control-systems**: Feedback control
- **complex-networks**: Complex network theory
## Limitations
- Requires sufficient temporal data
- Early warning signals may be noisy
- Bistability detection challenging in high dimensions
- Percolation models simplified vs. real systems
## Future Directions
1. Machine learning for early warning signal fusion
2. Multi-layer network robustness analysis
3. Adaptive resilience design optimization
4. Integration with control theory for resilience control
5. Quantum network robustness analysis
---