A Computational Framework for Temporal Archaeology and Civilizational Dynamics Using AI and Complex Systems Modeling
| Badge | Status |
|---|---|
| Version |  |
| License |  |
| Status |  |
| Python |  |
| PyPI |  |
| DOI |  |
| OSF |  |
| Website |  |
- Overview
- Abstract
- OSF Preregistration
- Official Website
- Core Formalism
- Computational Architecture
- Simulation Algorithm
- Variable Index
- Project Structure
- Installation
- Quick Start
- Applications
- Limitations and Assumptions
- Distribution Platforms
- Citation
- Author
- License
CHRONO-ARCH treats civilizations as coupled nonlinear spatiotemporal dynamical systems embedded in evolving environmental and interaction fields. Rather than producing static reconstructions of the past, it formulates civilizational evolution as a set of computable, probabilistic, and graph-theoretic mathematical structures that enable:
- Simulation of long-term civilizational trajectories under varied conditions
- Inference of hidden historical structures from fragmentary archaeological evidence
- Collapse modeling as endogenous phase transitions with early-warning signal diagnostics
- Counterfactual analysis of historical what-if questions via formal do-calculus
The framework is simultaneously a theoretical specification, a computational architecture, and an open-source Python implementation.
"The goal is not to predict the past, but to understand the space of pasts consistent with the evidence — and the space of futures consistent with the present."
CHRONO-ARCH introduces a computational framework for modeling civilizations as nonlinear, temporally evolving dynamical systems embedded in environmental, economic, and networked interaction fields. Unlike traditional archaeological approaches that rely on static reconstruction, the framework formulates civilizations as coupled spatiotemporal systems governed by differential dynamics, probabilistic state transitions, and evolving interaction graphs.
The core system is expressed as a nonlinear operator-valued ordinary differential equation over a time-dependent graph, augmented with a Fokker-Planck probabilistic layer and a causal inference module. All components are formally specified, computationally interpretable, and grounded in measurable variables.
Keywords: Civilizational Dynamics · Temporal Graph Networks · Dynamical Systems · Complex Systems · Causal Inference · Probabilistic Modeling · Environmental Coupling · Collapse Theory · Archaeological AI · Phase Transitions · Knowledge Diffusion · Fokker-Planck Equation
This project has been formally preregistered on the Open Science Framework (OSF).
| Field | Value |
|---|---|
| Registration Type | OSF Preregistration |
| Registry | OSF Registries |
| Associated Project | https://osf.io/bfd8g |
| Date Created | May 22, 2026, 6:12 AM |
| Date Registered | May 22, 2026, 6:12 AM |
| License | MIT License |
| Internet Archive | archive.org/details/osf-registrations-2bwzd-v1 |
| Registration DOI | 10.17605/OSF.IO/2BWZD |
The CHRONO-ARCH framework has an official documentation website with live dashboard, results, and full documentation.
| Page | URL |
|---|---|
| 🏠 Home | https://chronoarch.netlify.app |
| ⚙️ Dashboard | https://chronoarch.netlify.app/dashboard |
| 📊 Results | https://chronoarch.netlify.app/results |
| 🐝 Documentation | https://chronoarch.netlify.app/documentation |
| 📋 OSF Registration | https://chronoarch.netlify.app/registration |
A civilization at time t is represented as a real-valued state vector:
C(t) ∈ ℝⁿ
| Component | Domain | Description |
|---|---|---|
C₁(t) |
[0, 1] |
Environmental adaptation index |
C₂(t) |
ℝ₊ᵐ |
Resource availability (vector) |
C₃(t) |
ℝ₊ |
Technological complexity scalar |
C₄(t) |
[0, 1] |
Sociopolitical stability index |
C₅(t) |
ℝ₊ |
Demographic pressure |
C₆(t) |
ℝ |
Economic integration measure |
Cₙ(t) |
— | n-th subsystem state variable |
The fundamental dynamics of the state vector:
dC(t)/dt = F( C(t), E(t), G(t), t ) (Eq. 2)
Nonlinear expansion:
dC/dt = A·C + Cᵀ·B·C + G(E, G_graph) (Eq. 3)
| Term | Symbol | Description |
|---|---|---|
| Linear | A·C |
Linear growth or decay (stability matrix) |
| Quadratic | Cᵀ·B·C |
Nonlinear interaction amplification |
| Coupling | G(E,G) |
Environmental and network coupling |
The operator F is Lipschitz-continuous in C for theoretical well-posedness. Numerical integration via Runge-Kutta or Euler-Maruyama is required for all but the most idealized cases.
Civilizations interact through a time-varying weighted graph:
G(t) = ( V, A(t) ) (Eq. 4)
A_ij(t) = f( trade_ij(t), conflict_ij(t), migration_ij(t), κ_ij(t) )
The adjacency matrix A(t) co-evolves with the state vector C(t):
dC/dt = F( C(t), E(t), G(t) ) ← state dynamics (Eq. 5a)
dA/dt = Φ( A(t), C(t) ) ← graph dynamics (Eq. 5b)
dE/dt = ξ(t) ← environmental (Eq. 5c)
Graph-theoretic diagnostic measures:
| Measure | Expression | Interpretation |
|---|---|---|
| Degree Centrality | k_i(t) = Σ_j A_ij(t) |
Influence of civilization i |
| Clustering Coefficient | f(triangles, A) |
Regional cohesion and alliance density |
| Betweenness Centrality | Σ σ_jk(i)/σ_jk |
Intermediary role in trade and information |
| Fiedler Eigenvalue | λ₂(L(t)) |
Algebraic connectivity; fragmentation risk |
| Spectral Radius | `ρ(A(t)) = max | λᵢ(A) |
E(t) = [ climate(t), temperature(t), precipitation(t) ]ᵀ (Eq. 6)
F_E = Γ · ∇E(t) (Eq. 7)
Vulnerability index:
V_env(t) = ‖ Γ · ∇E(t) ‖₂ (Eq. 8)
Γ ∈ ℝⁿˣᵏ— environmental sensitivity tensor (calibrated via MLE against known collapse events)- High
V_env(t)with low stabilityS(t)→ elevated collapse risk
Linear diffusion on temporal graph:
dK_i/dt = Σ_{j≠i} A_ij(t) · ( K_j − K_i ) (Eq. 9)
Generalized nonlinear form:
dK/dt = −L(t)·K + Ψ(K, A) (Eq. 10)
L(t) = D(t) − A(t) (graph Laplacian)
Absorptive capacity model:
Ψᵢ(K, A) = α · Kᵢᵝ · Σ_j A_ij · max(K_j − K_i, 0) (Eq. 11)
β > 1 superlinear absorptive capacity
α ∈ (0, 1] institutional openness parameter
Archaeological data is inherently incomplete. CHRONO-ARCH operates at the level of probability distributions over state trajectories.
Stochastic evolution (Itô SDE):
dC = F(C, E, G) dt + σ(C) dW (Eq. 12)
Fokker-Planck equation:
∂P(C,t)/∂t = −∇·(P·F) + D·∇²P (Eq. 13)
drift: −∇·(P·F) deterministic dynamics
diffusion: D·∇²P uncertainty / stochasticity
Sequential Bayesian assimilation:
P(C,t | data_{1:t}) ∝ L(data_t | C) · P(C,t | data_{1:t-1}) (Eq. 14)
Collapse is modeled as an endogenous phase transition, not an exogenous shock.
Stability functional:
S(t) = Σᵢ wᵢ · Cᵢ(t) − λ · σ(E(t)) (Eq. 15)
Collapse criterion: S(t) < θ_c
Phase transition condition:
φ(C) = ∇_C S(C) (Eq. 16)
Criticality: ‖φ(C)‖ → ∞ as C → C_crit
Phase classification:
| Phase | Condition | Behavior | Resilience |
|---|---|---|---|
| Phase I — Stable | S(t) >> θ_c |
Converges to attractor | Resilient to moderate shocks |
| Phase II — Critical | S(t) ≈ θ_c |
Sensitivity diverges; rising variance | Fragile; elevated collapse risk |
| Phase III — Collapse | S(t) < θ_c |
Transition to new attractor | Recovery requires strong shocks |
Early warning signals:
Var[C(t)] ↑ as t → t_collapse rising variance (Eq. 17a)
AC₁(t) ↑ as t → t_collapse lag-1 autocorrelation (Eq. 17b)
τ_relax(t) ↑ as t → t_collapse critical slowing down (Eq. 17c)
Three levels of causal knowledge following Pearl's causal ladder:
Causal graph:
G_causal = (V_causal, E_causal) (Eq. 18)
Causal effect via do-calculus:
P( C | do(X = x) ) = ∫ P(C | X=x, Z=z) · P(Z=z) dz (Eq. 19)
Counterfactual query: E[ C_t | do(X = x), C_{1:t-1} = c ]
Answers questions of the form: "What would have happened to civilization i had the climate event at time t not occurred?"
CHRONO-ARCH is organized as a four-layer architecture:
┌─────────────────────────────────────────────────────────┐
│ LAYER IV — Simulation & Scenario Analysis │
│ Agent-based modeling · Counterfactual scenarios · │
│ Phase diagrams · Collapse risk assessment │
├─────────────────────────────────────────────────────────┤
│ LAYER III — Model & Inference │
│ Temporal GNN · SDE Simulator · │
│ Fokker-Planck Solver · Causal Graph Learner │
├─────────────────────────────────────────────────────────┤
│ LAYER II — Embedding & Fusion │
│ Temporal embeddings · Graph embeddings · │
│ Multimodal fusion · Missing data imputation │
├─────────────────────────────────────────────────────────┤
│ LAYER I — Data Ingestion & Representation │
│ Archaeological datasets · Paleoclimate proxies · │
│ Geospatial data · Textual corpora · Trade/conflict │
└─────────────────────────────────────────────────────────┘
Temporal Graph Neural Network (TGNN) update rule:
hᵢ^(t+1) = σ( W_self · hᵢᵗ + Σ_j A_ij(t) · W_nb · hⱼᵗ + b ) (Eq. 20)
Algorithm 1 — CHRONO-ARCH Simulation Loop
INPUT: C₀, E₀, G₀, T (time horizon), θ_c, dt
OUTPUT: { C(t), S(t), K(t), P(C,t), events } for t ∈ [0, T]
INITIALIZE:
C ← C₀ ; E ← E₀ ; G ← G₀ ; events ← []
FOR t = 1 TO T:
RETURN { C, S, K, P, events, EWS }
| Symbol | Domain | Description | Data Source |
|---|---|---|---|
C(t) |
ℝⁿ |
Civilizational state vector | Inferred / reconstructed |
E(t) |
ℝᵏ |
Environmental forcing field | Paleoclimate proxy data |
G(t) |
Graph | Inter-civilizational network | Trade / conflict records |
A(t) |
ℝᴺˣᴺ |
Weighted adjacency matrix | Derived from G(t) |
K_i(t) |
ℝ₊ |
Knowledge level of node i | Textual corpus inference |
L(t) |
ℝᴺˣᴺ |
Graph Laplacian at time t | Computed from A(t) |
S(t) |
ℝ |
Stability functional | Derived quantity |
P(C,t) |
[0,1] |
State probability density | Fokker-Planck solution |
Γ |
ℝᵏˣⁿ |
Environmental sensitivity tensor | Model parameter (calibrated) |
θ_c |
ℝ |
Collapse threshold | Calibrated from case studies |
CHRONO-ARCH/
│
├── chrono_arch/ # Core Python package
│ ├── init.py
│ ├── state/
│ │ ├── init.py
│ │ ├── state_vector.py # Civilizational state vector C(t)
│ │ ├── evolution.py # Master evolution equation (Eq. 2–3)
│ │ └── initializer.py # State initialization utilities
│ │
│ ├── graph/
│ │ ├── init.py
│ │ ├── temporal_graph.py # Temporal interaction graph G(t) (Eq. 4)
│ │ ├── co_evolution.py # Co-evolving system Φ (Eq. 5a–5c)
│ │ ├── graph_measures.py # Centrality, Laplacian, Fiedler value
│ │ └── tgnn.py # Temporal GNN update rule (Eq. 20)
│ │
│ ├── environment/
│ │ ├── init.py
│ │ ├── env_model.py # Environmental forcing E(t) (Eq. 6)
│ │ ├── coupling.py # Sensitivity tensor Γ (Eq. 7)
│ │ └── vulnerability.py # Vulnerability index V_env (Eq. 8)
│ │
│ ├── diffusion/
│ │ ├── init.py
│ │ ├── knowledge_diffusion.py # Linear diffusion (Eq. 9–10)
│ │ └── absorptive_capacity.py # Nonlinear Ψ model (Eq. 11)
│ │
│ ├── probabilistic/
│ │ ├── init.py
│ │ ├── sde.py # Stochastic SDE (Eq. 12)
│ │ ├── fokker_planck.py # Fokker-Planck PDE (Eq. 13)
│ │ ├── particle_filter.py # SMC/particle filter for high-dim
│ │ └── bayesian_assimilation.py # Sequential Bayesian update (Eq. 14)
│ │
│ ├── collapse/
│ │ ├── init.py
│ │ ├── stability.py # Stability functional S(t) (Eq. 15)
│ │ ├── phase_transition.py # Phase detection (Eq. 16)
│ │ └── early_warning.py # EWS signals Var, AC1, τ (Eq. 17)
│ │
│ ├── causal/
│ │ ├── init.py
│ │ ├── causal_graph.py # DAG structure (Eq. 18)
│ │ ├── do_calculus.py # Intervention estimator (Eq. 19)
│ │ └── counterfactual.py # Counterfactual query engine
│ │
│ └── simulation/
│ ├── init.py
│ ├── engine.py # Algorithm 1 — main simulation loop
│ ├── agent_based.py # Agent-based layer
│ ├── scenario.py # Counterfactual scenario builder
│ └── phase_diagram.py # Bifurcation / phase space analysis
│
├── layers/ # Four-layer architecture
│ ├── layer1_ingestion/
│ │ ├── archaeological.py # Site inventories, radiocarbon dates
│ │ ├── paleoclimate.py # Isotope records, pollen, speleothems
│ │ ├── geospatial.py # Settlement maps, territorial data
│ │ ├── textual_nlp.py # NLP encoding of textual corpora
│ │ └── trade_conflict.py # Network edge data reconstruction
│ │
│ ├── layer2_embedding/
│ │ ├── temporal_embed.py # Gaussian process interpolation
│ │ ├── graph_embed.py # node2vec + temporal embeddings
│ │ ├── fusion_encoder.py # Multimodal late-fusion architecture
│ │ └── imputation.py # MICE / VAE missing data imputation
│ │
│ ├── layer3_inference/
│ │ ├── model_interface.py # Unified model API
│ │ └── parameter_calibration.py # MLE / Bayesian parameter estimation
│ │
│ └── layer4_simulation/
│ ├── forward_sim.py # Ensemble forward simulation
│ ├── counterfactual_sim.py # Do-calculus scenario simulation
│ └── viz.py # Phase diagrams, trajectory plots
│
├── data/
│ ├── examples/ # Example datasets for quick start
│ │ ├── bronze_age_collapse.csv
│ │ ├── maya_classic_terminal.csv
│ │ └── roman_network.json
│ ├── schemas/ # Data format specifications
│ └── README.md
│
├── benchmarks/
│ ├── collapse_detection/ # Phase transition detection benchmarks
│ ├── diffusion_accuracy/ # Knowledge diffusion validation
│ └── probabilistic_calibration/ # Fokker-Planck calibration tests
│
├── tests/
│ ├── unit/
│ │ ├── test_state_vector.py
│ │ ├── test_temporal_graph.py
│ │ ├── test_fokker_planck.py
│ │ ├── test_stability.py
│ │ └── test_causal_graph.py
│ └── integration/
│ ├── test_simulation_loop.py
│ └── test_full_pipeline.py
│
├── notebooks/
│ ├── 01_quickstart.ipynb # Getting started walkthrough
│ ├── 02_bronze_age_collapse.ipynb # 4.2 kya event case study
│ ├── 03_maya_collapse.ipynb # Terminal Classic Maya case study
│ ├── 04_knowledge_diffusion.ipynb # Diffusion dynamics demo
│ ├── 05_phase_diagrams.ipynb # Phase space visualization
│ └── 06_counterfactuals.ipynb # Do-calculus counterfactual queries
│
├── docs/
│ ├── theory.md # Extended theoretical documentation
│ ├── api_reference.md # Full API reference
│ ├── assumptions.md # Formal assumption register A1–A6
│ └── limitations.md # Systematic limitation analysis
│
├── config/
│ ├── default.yaml # Default simulation parameters
│ ├── collapse_thresholds.yaml # Calibrated θ_c values by region/era
│ └── sensitivity_tensors.yaml # Pre-calibrated Γ tensors
│
├── Netlify/ # Official website source
│ ├── index.html # Home page
│ ├── dashboard.html # Live dashboard
│ ├── results.html # Benchmark results
│ ├── documentation.html # Documentation
│ └── registration.html # OSF registration
│
├── THEORETICAL_FRAMEWORK.md # Full mathematical specification
├── CHANGELOG.md # Version history
├── REPRODUCIBILITY.md # Reproducibility guide
├── AUTHORS.md # Author information
├── EVALUATION_PROTOCOL.md # Validation and evaluation protocol
├── REAL_WORLD_BENCHMARK_PLAN.md # Planned benchmark datasets
├── requirements.txt # Python dependencies
├── setup.py # Package setup
├── pyproject.toml # Build configuration
├── LICENSE # MIT License
└── README.md # This file
From PyPI (recommended):
pip install chrono-archFrom source:
git clone https://github.com/gitdeeper12/CHRONO-ARCH.git
cd CHRONO-ARCH
pip install -e .Dependencies:
numpy >= 1.24
scipy >= 1.10
networkx >= 3.0
torch >= 2.0 # TGNN component
torch-geometric >= 2.3
pandas >= 2.0
matplotlib >= 3.7
scikit-learn >= 1.3
pgmpy >= 0.1.21 # Causal graph learning
- Quick Start
from chrono_arch.simulation import Engine
from chrono_arch.state import StateVector
from chrono_arch.graph import TemporalGraph
# Initialize civilizational state
C0 = StateVector(
environmental_adaptation=0.7,
resource_availability=[1.2, 0.8, 1.5],
technological_complexity=0.45,
sociopolitical_stability=0.6,
demographic_pressure=0.4,
economic_integration=0.55
)
# Define initial interaction network
G0 = TemporalGraph.from_edge_list([
("CivA", "CivB", {"trade": 0.8, "conflict": 0.1}),
("CivB", "CivC", {"trade": 0.5, "migration": 0.3}),
])
# Run simulation
engine = Engine(collapse_threshold=0.25, dt=1.0)
results = engine.simulate(C0=C0, G0=G0, T=500)
# Check for collapse events
for event in results.events:
print(f"[t={event.t}] {event.type} detected — S(t) = {event.stability:.4f}")
# Plot early warning signals
results.plot_early_warning_signals()Counterfactual query (do-calculus):
from chrono_arch.causal import DoCalculus
do = DoCalculus(results.causal_graph)
# What if the 4.2 kya drought had not occurred?
counterfactual = do.intervene(
variable="precipitation",
value=1.0, # Normal precipitation level
time_range=(4200, 4100)
)
print(counterfactual.expected_stability())- Applications
Application Domain Key Framework Component Primary Equations Computational Archaeology Bayesian state inference Eq. 13–14 Climate-Civilization Modeling Environmental sensitivity tensor Γ Eq. 6–8 Historical Simulation Full simulation loop Algorithm 1 Cultural Diffusion Analysis Knowledge diffusion on temporal graph Eq. 9–11 Collapse Prediction Research Phase transition + EWS Eq. 15–17 Digital Humanities AI Multimodal fusion + TGNN Eq. 20
- Limitations and Assumptions
Formal assumption register:
ID Assumption A1 F is Lipschitz-continuous in C (ensures ODE well-posedness) A2 E(t) is exogenous — no feedback from civilizational state to climate A3 Civilizational node boundaries are resolvable in the data (identifiability) A4 Archaeological proxies are conditionally independent given C(t) A5 Collapse is a low-probability absorbing state (not guaranteed recovery) A6 The causal graph G_causal is acyclic within each time-slice
Known limitations:
Limitation Impact Mitigation Data incompleteness Wide credible intervals Marginalization; missing data models Temporal uncertainty Inflated trajectory variance Bayesian date calibration; IntCal23 Non-identifiability Multiple configs fit observations Regularization; informative priors Historical non-determinism No unique prediction Ensemble forecasting; do-calculus High-dim Fokker-Planck Analytically intractable Particle filters; variational inference Over-interpretation risk Precision may exceed epistemic warrant Mandatory uncertainty reporting
Note: CHRONO-ARCH is a descriptive and inferential framework. Numeric outputs carry formal uncertainty bounds and should not be interpreted as deterministic historical predictions.
- Distribution Platforms
1 GitHub (Primary) https://github.com/gitdeeper12/CHRONO-ARCH ✅ 2 GitLab (Mirror) https://gitlab.com/gitdeeper12/CHRONO-ARCH ✅ 3 Bitbucket (Mirror) https://bitbucket.org/gitdeeper-12/CHRONO-ARCH ✅ 4 Codeberg (Mirror) https://codeberg.org/gitdeeper12/CHRONO-ARCH ✅ 5 PyPI https://pypi.org/project/chrono-arch ✅ 6 Zenodo Archive https://doi.org/10.5281/zenodo.20330475 ✅ 7 Official Website https://chronoarch.netlify.app ✅
- Citation
General Citation
If you use CHRONO-ARCH in your research, please cite:
@software{baladi2026chronoarch,
author = {Baladi, Samir},
title = {CHRONO-ARCH: A Computational Framework for Temporal Archaeology
and Civilizational Dynamics Using AI and Complex Systems Modeling},
year = {2026},
version = {1.0.0},
doi = {10.5281/zenodo.20330475},
url = {https://github.com/gitdeeper12/CHRONO-ARCH},
license = {MIT}
}OSF Preregistration Citation
@misc{baladi2026chronoarchprereg,
author = {Baladi, Samir},
title = {CHRONO-ARCH: Preregistration of Computational Framework for Temporal Archaeology},
year = {2026},
doi = {10.17605/OSF.IO/2BWZD},
url = {https://osf.io/bfd8g}
}DOI: 10.5281/zenodo.20330475
Related Projects: ENTRO-PATH · DSFT / IKPS-CORE · EntropyLab Series
- Author
Samir Baladi Independent Researcher — Ronin Institute / Rite of Renaissance
· ORCID: 0009-0003-8903-0029 · Email: gitdeeper@gmail.com · GitHub: gitdeeper12 · GitLab: gitdeeper12 · Zenodo: 10.5281/zenodo.20330475
- License
This project is released under the MIT License.
MIT License
Copyright (c) 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.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
CHRONO-ARCH v1.0.0 · MIT License · May 2026
📄 Paper · 🐙 GitHub · ⛓ GitLab · 🐍 PyPI · 🌐 Website · 📋 OSF · 👤 ORCID
Preprint — Not Peer-Reviewed