A computational approach to emergent spacetime, gravity, and quantum mechanics.

HCSN (Holographic Computational Spin-Network) explores the hypothesis that the universe is fundamentally computational — discrete events and causal relations give rise to spacetime, gravity, and quantum features.

✨ Highlights

• Minimal, local rewrite rules drive evolution.
• Diagnostics test emergence of time, dimensionality, and metric structure.
• Designed as a research playground: toy universes, experiments, and visualization.

Table of Contents

• Overview
• Docs
• Axioms
• Repository Structure
• Quick Start
• How to Run a Toy Universe
• Diagnostics Explained
• Stable Spacetime-like Behavior
• Current Research Focus
• Contributing
• Acknowledgements & License

HCSN proposes a discrete, causal, and computational substrate:

• Events are vertices in a hypergraph; relations are (hyper)edges.
• Dynamics are local rewrite rules (edge creation, vertex fusion).
• Geometry, dimension, and time are emergent, not fundamental.

The long-term goal is to identify the minimal rule set that produces universes consistent with:

• Lorentz invariance (emergent)
• 4D spacetime structures
• Holographic scaling of information
• Quantum probabilistic behavior (Born rule)

This is full Documentation of this theory. Click here to read the Documentation

HCSN-Theory/
├── engine/                # Core simulation engine
│   ├── hypergraph.py      # Vertices, hyperedges, causality
│   ├── rules.py           # Rewrite rules
│   ├── rewrite_engine.py  # Acceptance dynamics
│   └── observables.py     # Physical diagnostics
├── experiments/           # Reproducible experiments
│   ├── exp_phase_diagram.py
│   ├── exp_critical_scan.py
│   └── exp_worldline_interactions.py
├── notebooks/             # Visualization & exploration (Jupyter)
├── figures/               # Generated plots & assets
├── theory/                # Conceptual documentation
│   └── hcsn_summary.md
└── README.md

Requirements

• Python 3.10 or later
• No external dependencies by default (pure Python). If notebooks or plotting are used, consider: matplotlib, numpy, jupyter.

Clone and run:

git clone https://github.com/hcsn-theory/HCSN-Theory.git
cd HCSN-Theory
python3 run_simulation.py

This runs a toy universe and prints diagnostics every N steps (see config/flags in the engine if present).

1. Configure parameters (if available) in engine or via command-line flags.
2. Start the simulation:
   • python3 run_simulation.py
3. Key printed diagnostics (periodic):
   • average coordination ⟨k⟩
   • causal depth (L)
   • interaction concentration (Φ)
   • closure density (Ψ)
   • hierarchical stability (Ω)

Tip: Increase logging or enable snapshotting in rewrite_engine.py for analysis and visualization.

Interpretation guide:

• ⟨k⟩ ≈ 7.5–8.5 → spacetime-like, stable geometry.
• Small Φ → suppressed hubs, more uniform interactions.
• Non-zero Ω across scales → hierarchical persistence and robustness.

Empirical indicators in simulations:

• ⟨k⟩ stabilizes near 7.5–8.5
• Φ remains small (no runaway hub formation)
• Ω > 0 across multiple scales
• Closure density Ψ indicates sufficient redundancy for persistent structure

Negative results (failures) are equally valuable — they highlight missing axioms or rule constraints.

Active directions:

• Prevent metric collapse under coarse-graining
• Implement logarithmic information metrics (holographic tests)
• Enforce holographic bounds dynamically in evolution
• Search for Lorentz-invariant fixed points of the rule dynamics
• Explore mechanisms that produce quantum probabilistic outcomes (Born rule)

We welcome contributions from:

• physicists (GR, QFT, quantum gravity)
• mathematicians (graph theory, category theory)
• programmers (simulation performance, visualization)
• curious minds who can test assumptions

Getting started:

1. Fork the repo, create a feature branch.
2. Add reproducible experiments under experiments/.
3. Document new rules, diagnostics, and observed behaviors.
4. Open PRs with clear descriptions, expected behavior, and reproducibility notes.

Guidelines:

• Write reproducible code and seed RNGs where appropriate.
• Add tests or small example scripts demonstrating changes.
• Keep changes modular — new rules or observables should live in engine/.

See notebooks/ for visualization experiments and step-by-step explorations. If a plotting stack is available, export snapshots to figures/ for inclusion in reports.

If you use HCSN-Theory in research, please cite the repo and include a reference to the simulation version/commit used. Consider adding a DOI via Zenodo for formal citation.

Please cite it as follows:

The HCSN Research Group, @hcsn. (2025). The Holographic Computational Spin-Network (HCSN): Theory & Simulation (Version 1.0.0) [Computer software]. https://github.com/hcsn-theory/HCSN-Theory

For LaTeX/Overleaf users:

@software{HCSN2025,
  author = {The HCSN Research Group, @hcsn.},
  title = {The Holographic Computational Spin-Network (HCSN): Theory & Simulation},
  version = {1.0.0},
  year = {2025},
  url = {[https://github.com/hcsn-theory/HCSN-Theory](https://github.com/hcsn-theory/HCSN-Theory)}
}

This project is active research and published under Apache 2.0 licence. For collaboration or questions, open an issue or contact the maintainers via GitHub: hcsn-theory

The HCSN Research Group is maintained by @hcsn.

Philosophy

“The universe may not be described by computation — it may be computation.”

HCSN treats this as a testable hypothesis: build minimal computational rules and examine what emerges.

Enjoy exploring! 🧩