A Variational and Continuum Mechanics Framework for Collective Stability in Autonomous Swarm Systems
"The swarm is not a collection of agents. It is a single thought, distributed across a thousand bodies, moving through the geometry of its own potential. SWARMICA gives that thought a direction — and proves, mathematically, that it will arrive."
— SWARMICA Manifesto
"From classical mechanics to neural operators, from PDE solvers to autonomous law discovery — SWARMICA has evolved into a unified continuum swarm physics platform for scientific research."
- Overview
- The Problem
- Core Constructs
- Mathematical Foundation
- Key Results
- Project Structure
- Installation
- Quick Start
- Validation Scenarios
- Reproducibility Infrastructure
- OSF Preregistration
- Version History
- Citation
- Author
- License
SWARMICA is a Variational and Continuum Mechanics framework for collective swarm stability that treats the swarm not as a collection of discrete reactive agents but as a continuous active matter field evolving on a Physical Coupling Manifold under the Principle of Least Action.
Where conventional swarm control methods — Boids rules, consensus protocols, artificial potential fields — provide heuristic coordination without global stability guarantees, SWARMICA derives the swarm's collective equations of motion from a variational action functional, certifies stability through Jacobian eigenvalue analysis at the global attractor Q*, and drives inter-agent phase alignment through a modified Kuramoto synchronization layer that collapses the swarm's internal degrees of freedom from 6N to 6.
The framework is built on three mathematically rigorous constructs:
| Construct | Role |
|---|---|
| Collective Lagrangian Operator (CLO) | Derives swarm trajectory equations from a variational action functional over the generalized coordinate space of the continuum density field |
| Effective Potential Field Engine (EPFE) | Engineers the swarm potential landscape via Sum-of-Squares (SOS) semidefinite programming to guarantee a unique global attractor at Q* — eliminating all local minima by construction |
| Kuramoto Phase Synchronization Layer (KPSL) | Drives inter-agent phase alignment above the critical coupling threshold K_c, collapsing the swarm into a mechanically rigid collective body |
Conventional swarm control faces three fundamental barriers that SWARMICA resolves:
1. The Scalability Barrier Discrete agent-based stability proofs require either all-to-all connectivity (O(N²) messages per step) or graph-connectivity conditions that are difficult to maintain in dynamic environments. The state space of an N-agent 3D system has dimension 6N — making Lyapunov analysis computationally intractable for N > 10³ and unrealizable for the N = 10⁴ to 10⁶ agent counts of next-generation applications.
2. The Local Minima Trap Artificial potential field methods suffer from spurious local attractors in obstacle-dense environments. In the SWARMICA ground-convoy benchmark, naive potential field controllers trap formations in 34% of Monte Carlo runs. The EPFE's SOS parameterization eliminates local minima by construction, and the CLO's kinetic coherence mechanism allows the collective body to traverse residual obstacle barriers without becoming trapped.
3. The Phase Disorder Loss Disordered internal agent phases dissipate a significant fraction of the collective kinetic energy into destructive internal oscillations rather than directed motion. The KPSL drives all agent phases to a common target above K_c, producing a mechanically rigid collective body whose effective degrees of freedom collapse from 6N to 6 — channeling all kinetic energy into the collective trajectory toward Q*.
The CLO represents the swarm as a continuum density field ρ(x,t) and velocity field v(x,t) on the Physical Coupling Manifold M, deriving the collective equations of motion from the Principle of Least Action:
Lagrangian:
L[Q, Q̇] = T[Q̇] − V_eff[Q]
= ½ ∫ ρ|v|² dx − ∫ ρ(x) V(x) dx
Collective Euler-Lagrange Field Equations:
G(Q) Q̈ + C(Q, Q̇) Q̇ + ∇_Q V_eff(Q) = F_ctrl
Physical Coupling Manifold State:
p(t) = (ρ(x,t), v(x,t)) ∈ M
∫ ρ(x,t) dx = N [agent count conservation]
Key property: the Euler-Lagrange equations have the same mathematical form regardless of N — all N-dependence is absorbed into the metric G(Q) and the Christoffel connection C(Q, Q̇). Stability analysis is N-independent by construction.
The EPFE constructs V_eff(Q) as a Sum-of-Squares (SOS) polynomial with a guaranteed unique global minimum at Q* — the target collective configuration:
SOS Parameterization:
V_eff(Q) = p(Q)ᵀ P p(Q) + α ‖Q − Q*‖²_G
where:
P ≽ 0 [positive semidefinite — computed via SDP / CVXPY + MOSEK]
p(Q) [monomial basis, degree ≤ 2d]
α > 0 [quadratic floor ensuring global strict convexity]
Global attractor guarantee:
V_eff(Q) > V_eff(Q*) for all Q ≠ Q*
∇_Q V_eff(Q*) = 0 [stationarity]
Hess V_eff(Q*) ≻ 0 [strict local convexity]
Kinetic coherence and barrier penetration:
T_coh(t) > ΔV_barrier(Q) → trajectory continues to Q*
The KPSL drives inter-agent phase alignment through a mean-field modified Kuramoto model:
Phase Dynamics:
dθᵢ/dt = ωᵢ + (K/N) Σⱼ sin(θⱼ − θᵢ) + F_ext,i(t)
Order Parameter (continuum limit):
r(t) e^{iφ(t)} = ∫ ρ(ω,t) e^{iθ(ω,t)} dω
Critical Coupling Threshold (Lorentzian g(ω)):
K_c = 2Δ
r_∞ = √(1 − K_c/K) for K > K_c
SWARMICA design: K = 3K_c [3× overcritical for robust synchronization]
Degree-of-Freedom Collapse at Full Synchronization:
dim(Phase Space)_disordered = 6N
dim(Phase Space)_synchronized = 6 [rigid body: 3 translational + 3 rotational]
DOF Reduction Ratio: ξ = 1 − 1/N → 1 as N → ∞
Input: Swarm state p(t) = (ρ(x,t), v(x,t)) on Physical Coupling Manifold M
│
▼
┌──────────────────────────────────────────────────────┐
│ Collective Lagrangian Operator (CLO) │
│ Basis expansion: Q ∈ R^{N_basis} (N_basis = 64) │
│ Metric: G(Q) Q̈ + C(Q,Q̇)Q̇ + ∇V_eff = F_ctrl │
│ Integration: Dormand-Prince RK45 adaptive step │
│ Frictionless limit: μ → 0 (asymptotic ceiling) │
└──────────────────────┬───────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────┐
│ Effective Potential Field Engine (EPFE) │
│ V_eff(Q) = p(Q)ᵀ P p(Q) + α‖Q−Q*‖²_G │
│ P ≽ 0 [SOS-SDP, degree d=4, MOSEK solver] │
│ Global attractor Q* — no local minima by design │
│ Basin radius: R_basin from sublevel set analysis │
└──────────────────────┬───────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────┐
│ Kuramoto Phase Synchronization Layer (KPSL) │
│ dθᵢ/dt = ωᵢ + (K/N)Σⱼ sin(θⱼ−θᵢ) + F_ext,i │
│ K = 3K_c → r(t) → 0.97 within 1.2 τ_A │
│ DOF collapse: 6N → 6 (rigid collective body) │
└──────────────────────┬───────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────┐
│ Jacobian Stability Certificate │
│ Re(λᵢ) < −σ_min < 0 ∀ i = 1…2N_basis │
│ σ_min = λ_min(Hess V_eff) / λ_max(G(Q*)) │
│ ‖Q(t)−Q*‖ ≤ C e^{−σ_min t} ‖Q(0)−Q*‖ │
└──────────────────────┬───────────────────────────────┘
│
▼
Output: F_ctrl(t) — actuator commands for all agents
CSI — Collective Stability Index ∈ [0,1]
r(t) — Kuramoto order parameter ∈ [0,1]
S_struct(t) — structural entropy
ERI — Entropy Reduction Index ∈ [0,1]
| # | Equation | Description |
|---|---|---|
| 1 | p(t) = (ρ(x,t), v(x,t)) ∈ M |
Physical Coupling Manifold state |
| 2 | T = ½ ∫ ρ(x)|v(x)|² dx = ½ Q̇ᵀG(Q)Q̇ |
Collective kinetic energy / manifold metric |
| 3 | L[Q,Q̇] = T[Q̇] − V_eff[Q] |
Ideal SWARMICA Lagrangian |
| 4 | G(Q)Q̈ + C(Q,Q̇)Q̇ + ∇_Q V_eff(Q) = F_ctrl |
Collective Euler-Lagrange equations |
| 5 | V_eff(Q) = p(Q)ᵀPp(Q) + α‖Q−Q*‖²_G |
SOS potential field |
| 6 | T_coh > ΔV_barrier ⟹ trajectory reaches Q* |
Kinetic coherence barrier penetration |
| 7 | L_μ = T − V_eff − μD[Q̇] |
Dissipative extension (physical μ > 0) |
| 8 | dθᵢ/dt = ωᵢ + (K/N)Σⱼsin(θⱼ−θᵢ) + F_ext,i |
Modified Kuramoto phase dynamics |
| 9 | K_c = 2Δ, r_∞ = √(1−K_c/K) |
Critical coupling and order parameter |
| 10 | dim_synchronized = 6 (vs 6N) |
DOF collapse at full synchronization |
| 11 | Re(λᵢ) < −σ_min < 0 |
Jacobian eigenvalue stability certificate |
| 12 | ‖Q(t)−Q*‖ ≤ C e^{−σ_min t}‖Q(0)−Q*‖ |
Exponential convergence bound |
| 13 | S_struct(t) = k_B ln(Ω(t)) |
Structural entropy of the swarm |
| 14 | ERI = 1 − S_struct(t_final) / S_struct(0) |
Entropy Reduction Index |
| 15 | B(Q*) ⊇ {Q : V_eff(Q) ≤ V_max} |
Basin of attraction via sublevel sets |
| Metric | Value |
|---|---|
| Mean Collective Stability Index (CSI) | 94.7% |
| Mean Entropy Reduction Index (ERI) | 88.3% vs. uncontrolled baseline |
| Mean convergence time to Q* | 2.3 τ_A (Alfvén-analog time units) |
| Formation collapse rate | < 1% vs. 34% for best competing method |
| Improvement over Vicsek + MPC hybrid | +11.1 pp CSI |
| Improvement over artificial potential fields | +21.9 pp CSI |
| N-independence | Proved — no CSI degradation N=50 to N=5,000 |
| Inference latency (A100 FP32, N=500) | 1.2 ms full control cycle (833 Hz) |
| Inference latency (Orin INT8, domain-selective) | 0.24 ms (4,167 Hz) |
| Total parameters (CLO + KPSL) | 24.6 M |
| Training compute | 620 GPU-hours (8× A100) |
SWARMICA/
│
├── README.md # This file
├── LICENSE # MIT License © 2026 Samir Baladi
├── CITATION.cff # Citation metadata (CFF format)
├── pyproject.toml # Build configuration
├── setup.py # Package setup
├── .gitlab-ci.yml # CI/CD: lint, test, benchmark, deploy
├── CHANGELOG.md # Release history (v1.0 → v13.0)
│
├── paper/
│ ├── SWARMICA_Research_Paper.pdf # Full academic paper (v1.0.0)
│ └── figures/
│ ├── fig1_pcm_manifold.png
│ ├── fig2_epfe_potential.png
│ ├── fig3_kpsl_synchronization.png
│ ├── fig4_jacobian_eigenvalues.png
│ ├── fig5_s1_aerial_formation.png
│ ├── fig6_s2_convoy_obstacles.png
│ ├── fig7_s3_underwater_school.png
│ ├── fig8_ablation_study.png
│ └── fig9_n_independence.png
│
├── swarmica/ # Core Python library (swarmica-engine)
│ ├── manifold/ # Physical Coupling Manifold
│ ├── field/ # CLO + EPFE + SOS optimizer
│ ├── synchronization/ # KPSL + Kuramoto order parameter
│ ├── stability/ # Jacobian certificate + basin estimator
│ ├── control/ # SwarmEngine top-level API
│ └── interface/ # Config, ROS2, TensorRT export
│
├── benchmarks/ # Validation scripts (S1–S4)
├── training/ # Three-phase training curriculum
├── notebooks/ # Jupyter walkthrough notebooks
├── examples/ # Minimal working examples
├── docs/ # API reference + guides
└── tests/ # Unit and integration tests
Requirements: Python ≥ 3.11 | PyTorch ≥ 2.4 | JAX ≥ 0.4 | NumPy ≥ 2.1 | SciPy ≥ 1.14 | CVXPY ≥ 1.4 (with MOSEK for SOS-SDP)
# Stable release from PyPI
pip install swarmica-engine
# Development install from source
git clone https://github.com/gitdeeper12/SWARMICA.git
cd SWARMICA
pip install -e .
# With CUDA-accelerated JAX
pip install swarmica-engine[cuda]
# With ROS2 bridge
pip install swarmica-engine[ros2]
# Full install (CUDA + ROS2 + MOSEK)
pip install swarmica-engine[full]Minimal example — 50-agent aerial diamond-V formation:
from swarmica import SwarmEngine, SwarmConfig
cfg = SwarmConfig(
n_agents = 50,
modality = 'aerial',
n_basis = 64,
k_coupling = 3.0,
mu_dissipation = 0.02,
target_config = 'diamond_V',
sos_degree = 4,
)
engine = SwarmEngine(cfg)
engine.load_weights('experiments/weights/swarmica_v1.0.0_aerial.pt')
for obs in sensor_stream:
ctrl = engine.step(dt=1e-3, obs=obs)
csi = engine.get_csi()
r = engine.get_order_parameter()
eri = engine.get_eri()
print(f"CSI={csi:.4f} | r={r:.4f} | ERI={eri:.4f}")Ground convoy through obstacle field:
from swarmica import SwarmEngine, SwarmConfig
cfg = SwarmConfig(
n_agents = 100,
modality = 'ground',
n_basis = 64,
k_coupling = 3.0,
mu_dissipation = 0.08,
target_config = 'convoy_line',
obstacle_field = True,
kinetic_coherence_boost = 1.5,
)
engine = SwarmEngine(cfg)
engine.load_weights('experiments/weights/swarmica_v1.0.0_ground.pt')
result = engine.run_scenario(
duration_s = 120.0,
control_hz = 100,
initial_state = initial_positions_velocities,
log_metrics = True,
)
print(f"Collapse events : {result.collapse_count}")
print(f"Mean CSI : {result.mean_csi:.4f}")
print(f"Conv. time : {result.convergence_time:.2f} τ_A")Run full validation benchmark:
python benchmarks/run_all_scenarios.py \
--weights experiments/weights/ \
--output results/ \
--scenarios S1 S2 S3 S4 \
--n_monte_carlo 50All results are mean values over 50 independent Monte Carlo runs with random initial condition sampling from within the basin of attraction B(Q*).
| ID | Scenario | Modality | N Agents | CSI | ERI | Conv. Time | Collapse Rate |
|---|---|---|---|---|---|---|---|
| S1 | Diamond-V aerial formation reconfiguration | Aerial (quadrotor) | 50–5,000 | 96.2% | 91.4% | 1.8 τ_A | < 1% |
| S2 | Ground convoy through dense obstacle field | Ground (UGV) | 10–500 | 94.1% | 87.9% | 2.4 τ_A | < 1% |
| S3 | Underwater school under ocean current disturbance | Underwater (AUV) | 20–1,000 | 93.8% | 86.2% | 2.6 τ_A | < 1% |
| S4 | Mixed-modality heterogeneous swarm | Aerial + Ground | 30–300 | 94.7% | 88.1% | 2.3 τ_A | < 1% |
| Mean | — | — | — | 94.7% | 88.3% | 2.3 τ_A | < 1% |
| Configuration | Mean CSI | Mean ERI | Conv. Time | Collapse Rate |
|---|---|---|---|---|
| No EPFE (random potential) | 31.4% | 18.7% | > 10 τ_A | 61% |
| EPFE only — no KPSL | 78.3% | 71.2% | 4.2 τ_A | 11% |
| KPSL only — no EPFE | 52.6% | 44.8% | 3.8 τ_A (partial) | 28% |
| EPFE + KPSL — no Jacobian certificate | 91.8% | 85.3% | 2.6 τ_A | 4% |
| SWARMICA v13.0.0 (Full) | 94.7% | 88.3% | 2.3 τ_A | < 1% |
| Method | Mean CSI | ERI | Conv. Time | N-independent? | Collapse Rate |
|---|---|---|---|---|---|
| Boids (Reynolds, 1987) | 44.2% | 29.1% | > 8 τ_A | Yes (heuristic) | 38% |
| Consensus Protocol (Olfati-Saber, 2004) | 67.3% | 55.8% | 5.1 τ_A | Partially | 22% |
| Artificial Potential Fields (Khatib, 1986) | 72.8% | 63.4% | 4.6 τ_A | No | 17% |
| Graph-theoretic Formation (Fax-Murray, 2004) | 79.1% | 70.2% | 3.9 τ_A | Partially | 12% |
| Vicsek + MPC hybrid | 83.6% | 76.4% | 3.2 τ_A | No | 8% |
| SWARMICA v13.0.0 (Full) | 94.7% | 88.3% | 2.3 τ_A | Yes (proved) | < 1% |
| Hyperparameter | Value |
|---|---|
| Basis dimension N_basis | 64 |
| SOS polynomial degree d | 4 |
| Kuramoto coupling K | 3.0 × K_c |
| CLO integration scheme | Dormand-Prince RK45 (adaptive step) |
| Control update rate | 1 kHz (1 ms) |
| EPFE α (quadratic floor) | 0.15 |
| Physics loss weight λ_1 | 8.0 (NTK-adaptive) |
| Training compute | 620 GPU-hours (8× A100) |
| Total parameters (CLO + KPSL) | 24.6 M |
| A100 FP32 inference (N=500) | 1.2 ms / 833 Hz |
| Orin INT8 inference (domain-selective) | 0.24 ms / 4,167 Hz |
| Platform | Identifier / URL | Content |
|---|---|---|
| GitHub (Primary) | github.com/gitdeeper12/SWARMICA | Source code, issues, contributions |
| GitLab (Mirror) | gitlab.com/gitdeeper12/SWARMICA | CI/CD pipelines, mirror |
| Bitbucket (Mirror) | bitbucket.org/gitdeeper-12/SWARMICA | Mirror repository |
| Codeberg (Mirror) | codeberg.org/gitdeeper12/SWARMICA | Mirror repository |
| Zenodo (Archive) | 10.5281/zenodo.20168278 | DOI, datasets, model weights, paper |
| PyPI | swarmica-engine | pip install swarmica-engine |
| ORCID | 0009-0003-8903-0029 | Author identifier (Samir Baladi) |
# Primary
git clone https://github.com/gitdeeper12/SWARMICA.git
# Mirrors
git clone https://gitlab.com/gitdeeper12/SWARMICA.git
git clone https://bitbucket.org/gitdeeper-12/SWARMICA.git
git clone https://codeberg.org/gitdeeper12/SWARMICA.gitpip install swarmica-engine # Stable release
pip install swarmica-engine[cuda] # CUDA-accelerated JAX
pip install swarmica-engine[full] # Full: CUDA + ROS2 + MOSEK
python benchmarks/run_all_scenarios.py # Full S1–S4 validation suite
python benchmarks/ablation_study.py # CLO / EPFE / KPSL ablation
python benchmarks/n_independence_test.py # N-scaling invariance test
python examples/quick_start.py # 50-agent aerial formation demo
python bin/swarmica_run.py --scenario S2 --n 200 # Run convoy scenario, 200 agentsThis project has been formally preregistered on the Open Science Framework (OSF) Registries, providing a timestamped, publicly archived record of the research design, hypotheses, and methodology prior to analysis.
| Field | Details |
|---|---|
| Registration Type | OSF Preregistration |
| Registry | OSF Registries |
| Associated Project | osf.io/trgkq |
| Registration DOI | 10.17605/OSF.IO/Q4N8E |
| Date Created | May 14, 2026, 4:58 PM |
| Date Registered | May 14, 2026, 4:58 PM |
| Internet Archive | archive.org/details/osf-registrations-q4n8e-v1 |
| Registration License | CC-By Attribution 4.0 International |
SWARMICA has evolved from a classical variational mechanics framework (v1.0) through eight major scientific paradigms to a full autonomous physical law discovery platform (v13.0). See CHANGELOG.md for complete release notes.
| Version | Release | Focus | Scientific Domain | Tests | Status |
|---|---|---|---|---|---|
| v13.0 | May 15, 2026 | Autonomous Physical Law Discovery | PDE Discovery + SINDy | 30 | Research |
| v12.0 | May 15, 2026 | Constrained Neural Physics | Hamiltonian Systems | 28 | Breakthrough |
| v11.0 | May 14, 2026 | Neural Operator Swarm Physics | Neural Operators | 36 | Frontier |
| v10.0 | May 14, 2026 | Neural Field + Inverse Physics | Scientific ML | 26 | Breakthrough |
| v9.0 | May 14, 2026 | PDE Swarm Physics | CFD + Active Matter | 13 | Alpha |
| v8.0 | May 14, 2026 | Unified Field Control | Agent-based Continuum | 23 | Stable |
| v2.0 | May 14, 2026 | Stochastic Continuum Dynamics | SDE Systems | 28 | Beta |
| v1.0 | May 14, 2026 | Classical Variational Mechanics | Lagrangian Dynamics | 28 | Stable |
The current release introduces a full PDE Discovery Engine powered by SINDy (Sparse Identification of Nonlinear Dynamics):
- PDE Library Builder — candidate term library:
[u, u², ∂u/∂x, ∂u/∂y, ∇²u, u·∂u/∂x, u·∂u/∂y, sin(u)] - Sparse Selector — Lasso regression:
min ||y - Θξ||² + α||ξ||₁ - Constraint Verifier — physical validity: mass conservation, positivity, boundedness
- Key result: 3 PDE terms discovered · 62.5% sparsity · physically valid
| Milestone | Target | Platform | Status |
|---|---|---|---|
| v13.0.0 release + PyPI | May 2026 | All GPUs | ✅ Complete |
| ROS2 bridge validation | Q3 2026 | ROS2 Humble | 🔄 In progress |
| v14.0 — experimental validation with real data | Q4 2026 | A100 cluster | 📐 Design phase |
| v14.0 — comparison with CFD literature | Q4 2026 | A100 cluster | 📐 Design phase |
| v15.0 — physical swarm deployment | Q2 2027 | Physical hardware | 📋 Planned |
| v15.0 — publication-ready framework | Q2 2027 | All GPUs | 📋 Planned |
| FPGA deployment | Q4 2027 | Xilinx Versal | 📋 Planned |
| Large-scale field trial (N > 10,000) | Q3 2028 | Physical hardware | 📋 Planned |
If you use SWARMICA in your research, please cite both the Zenodo software archive and the OSF preregistration.
@software{baladi2026swarmica,
author = {Baladi, Samir},
title = {{SWARMICA} v13.0.0: A Variational and Continuum Mechanics
Framework for Collective Stability in Autonomous Swarm Systems},
year = {2026},
month = {May},
publisher = {Zenodo},
doi = {10.5281/zenodo.20168278},
url = {https://doi.org/10.5281/zenodo.20168278},
note = {Biomedical \& Autonomous Systems Research Series.
Ronin Institute / Rite of Renaissance.
PyPI: pip install swarmica-engine}
}@misc{baladi2026swarmica_osf,
author = {Baladi, Samir},
title = {{SWARMICA}: Preregistration — Variational and Continuum Mechanics
Framework for Collective Stability in Autonomous Swarm Systems},
year = {2026},
month = {May},
publisher = {OSF Registries},
doi = {10.17605/OSF.IO/Q4N8E},
url = {https://doi.org/10.17605/OSF.IO/Q4N8E},
note = {OSF Preregistration. Associated project: https://osf.io/trgkq.
Archived: https://archive.org/details/osf-registrations-q4n8e-v1.
License: CC-By Attribution 4.0 International.}
}
@misc{baladi2026swarmica_pypi,
author = {Baladi, Samir},
title = {{swarmica-engine}: Python Package for Variational Swarm Control},
year = {2026},
month = {May},
howpublished = {Python Package Index (PyPI)},
url = {https://pypi.org/project/swarmica-engine/},
note = {Install: \texttt{pip install swarmica-engine}.
Ronin Institute / Rite of Renaissance. MIT License.}
}Samir Baladi Independent Researcher — Ronin Institute / Rite of Renaissance
- 📧 gitdeeper@gmail.com
- 🔗 ORCID: 0009-0003-8903-0029
- 🐙 GitHub
- 🦊 GitLab
- 🐝 swarmica-engine on PyPI
MIT License
Copyright © 2026 Samir Baladi
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
SWARMICA v13.0.0 — A Variational and Continuum Mechanics Framework for Collective Stability © 2026 Samir Baladi — Ronin Institute / Rite of Renaissance — MIT License Zenodo: 10.5281/zenodo.20168278 | OSF: 10.17605/OSF.IO/Q4N8E | PyPI: swarmica-engine