entropic-time

Overview

entropic-time is a computational physics stack that implements the Complex Action Theory / Entropic Proper Time (CAT/EPT) framework for quantum gravity and multiphysics simulation. The framework provides a concrete software realization of the idea that irreversibility --- the production of entropy --- defines a physically meaningful time variable capable of bridging quantum mechanics and general relativity.

The central construction is the complex action,

$$S ;=; S_R ;+; i,S_I, \qquad S_I ;\geq; 0$$

where the real part $S_R$ governs standard unitary dynamics and the non-negative imaginary part $S_I$ encodes accumulated irreversible change. Defining the entropic proper time as $\tau_{\mathrm{ent}} = S_I / \hbar$ and its rate as $\lambda = d\tau_{\mathrm{ent}} / dt$ produces a single scalar quantity that satisfies Kuchar's criteria for a time variable in quantum gravity: it is a spacetime scalar, monotonically non-decreasing, and fully determined by the quantum state.

This quantity $\lambda$ is the universal coupling variable in the stack. It enters each physics solver in a domain-appropriate form --- as a Lindblad dissipation rate in open quantum systems, a transport coefficient in hydrodynamics, a metric modification in numerical relativity --- and the solvers return updated entropy production that feeds back into $\lambda$. Self-consistency is enforced by Picard fixed-point iteration.

Three results follow directly from the complex action postulate and are implemented in the code:

1. The Lindblad master equation (Eq 103). The most general completely positive, trace-preserving Markovian evolution, $d\rho/dt = -(i/\hbar)[H_R, \rho] + \sum_k \bigl(L_k \rho L_k^\dagger

   • \tfrac{1}{2}{L_k^\dagger L_k, \rho}\bigr)$, is derived as a consequence of requiring $S_I \geq 0$.

2. Path-integral UV regulation (Eq 52). The partition function $Z = \int \mathcal{D}\phi,\exp\bigl(iS_R/\hbar - S_I/\hbar\bigr)$ acquires an exponential suppression factor $e^{-S_I/\hbar}$ that damps high-frequency modes without introducing an external cutoff.

3. Complex Einstein Field Equations (Eq 113). $G_{\mu\nu} + i\Lambda_{\mu\nu} = \kappa,(T_{\mu\nu} + iS_{\mu\nu})$, where $S_{\mu\nu}$ is the entropic stress-energy tensor obtained by varying $S_I$ with respect to the metric.

192 of 201 paper equations are implemented in Python and independently verified across six formal systems (Lean 4, PhysLean, Wolfram Language, SymPy/pytest, xAct tensor algebra, SageMath).

What Sets It Apart

Conventional multiphysics codes couple domains through operator splitting or ad hoc boundary conditions. entropic-time derives all inter-domain coupling from a single theoretical quantity ($\lambda$) with a well-defined physical interpretation at every scale --- from QED vacuum polarization at $10^{-15}$ m to cosmological structure formation. Concretely:

• Unified coupling. Quantum entropy production, viscous dissipation, and spacetime curvature all feed back through the same entropic rate $\lambda$. Adding a new physics domain requires only implementing one adapter: how $\lambda$ enters that solver, and what entropy it produces.
• Formal verification as a first-class concern. Every equation has a symbolic implementation checked against the paper across multiple proof systems. This level of cross-verification is not standard practice in physics simulation codes.
• Browser-native execution. Geant4 Monte Carlo compiled to WebAssembly, QuTiP via Pyodide, and JavaScript-based integrators run entirely client-side. An interactive dashboard provides equation-level drill-down, live simulations, and architecture visualization with no server.
• Compiled DSL. A two-target compiler (Python and Wolfram Language) lowers 13 high-level DSL commands through a canonical intermediate representation, checked by four semantic verification layers and 19 TLA+ specifications.

Capabilities

The stack spans nine physics domains. Each domain adapter translates $\lambda$ into the appropriate physical quantity for its solver and returns entropy production feedback to the coupling loop.

Quantum open systems. Lindblad/GKLS master equation evolution via QuTiP with automatic entropy tracking ($S(t)$, $\lambda(t)$, $\tau_{\mathrm{ent}}(t)$). Non-Markovian process tensors via OQuPy. Complex-action evolution with non-Hermitian Hamiltonians. This is the most mature integration in the stack.

Particle transport. Geant4 compiled to WebAssembly with a CAT/EPT physics overlay. Photoelectric, Compton, pair production, and hadronic processes with entropic proper time corrections. Runs entirely in-browser.

Numerical relativity. Adapters for Einstein Toolkit (Cactus thorn), AMSS-NKU 3+1 ADM decomposition, and SpECTRE generalized-harmonic formulation. These provide data structure translation and implement the Complex Einstein Field Equations (Eq 113). Picard iteration couples the gravitational sector to quantum state evolution via $\langle T_{\mu\nu} \rangle$ feedback.

Computational fluid dynamics. OpenFOAM adapter with entropic CFL conditions and bidirectional quantum-hydro coupling. A Lindblad backend maps viscous dissipation to collapse operators. Requires external OpenFOAM installation.

Electrodynamics. MEEP adapter for electromagnetic cavity simulations in curved spacetime with Gordon-formula effective permittivity and Maxwell stress-tensor feedback.

Condensed matter. Kwant quantum transport with entropic conductance suppression. PythTB tight-binding with metric-dependent hopping parameters.

Quantum chemistry. OpenFermion, PySCF, Psi4, and DIRAC adapters for molecular orbital entropy production.

QED. QEDTool vacuum polarization with entropic proper time regularization.

Quantum computing. Cirq/Qualtran resource estimation, qsim statevector simulation, MQT decision-diagram backends, PennyLane differentiable circuits.

Physics Engines

30 adapters coupled through a unified layer.

Domain	Engines	Coupling variable
Quantum open systems	QuTiP, OQuPy	$\rho(t)$, $S(t)$, $\lambda(t)$, $\tau_{\mathrm{ent}}(t)$
Numerical relativity	Einstein Toolkit, AMSS-NKU, SpECTRE	$g_{\mu\nu}$, $\alpha$, $K_{ij}$, $\Lambda_{\mu\nu}$
Fluid dynamics	OpenFOAM	$\nu_{\mathrm{eff}}$, Re, $\Phi$
Electrodynamics	MEEP	E/H fields, $T^{\mathrm{EM}}_{ij}$
QED	QEDTool	$\Pi(q^2)$
Particle transport	Geant4, pynucastro	$\sigma(E)$, reaction rates
Condensed matter	Kwant, PythTB	$G(E)$, $E_n(k)$
Quantum chemistry	Psi4, PySCF, DIRAC, OpenFermion	Fock matrix, orbital entropy
Quantum computing	Cirq, qsim, MQT, PennyLane	Resource estimates, statevectors

Limitations

• No built-in BSSN solver. Numerical relativity adapters provide data structure translation for external solvers but do not include a standalone spacetime evolution code. Coupled quantum-gravity simulations require an external GR installation.
• Adapter depth varies. QuTiP and Geant4 integrations perform real computation. Most other adapters (MEEP, DIRAC, Fluidity) are data-format bridges that degrade gracefully to mock mode when the underlying engine is not installed.
• No production-scale validation. Tests exercise the framework with toy problems (flat Minkowski metrics, small grids). Validation against published benchmark solutions remains future work.
• Single-node execution. No MPI or distributed-memory parallelism.
• Picard coupling is early-stage. The self-consistency loop between quantum and gravitational sectors is structurally complete but has only been exercised with mock AMSS data, not a live numerical relativity solver.

Theoretical Foundations

The CAT/EPT framework builds on and extends:

• Nagao & Nielsen — complex action path integral (Prog. Theor. Phys. 126, 2011)
• Lindblad; Gorini, Kossakowski & Sudarshan — GKLS master equation (Commun. Math. Phys. 48, 1976; J. Math. Phys. 17, 1976)
• Connes & Rovelli — thermal time hypothesis (Class. Quantum Grav. 11, 1994)
• Page & Wootters — timeless quantum mechanics (Phys. Rev. D 27, 1983)
• Jacobson — Einstein equation as equation of state (Phys. Rev. Lett. 75, 1995)
• Unruh — thermal radiation from acceleration (Phys. Rev. D 14, 1976)
• Margolus & Levitin; Landauer — quantum speed limit and erasure cost (Physica D 120, 1998; IBM J. Res. Dev. 5, 1961)

Requirements

Component	Version	Purpose
Python	3.8+	Core framework
NumPy, SymPy, pytest	latest	Numerical and symbolic computation
Lean 4	4.4.0+ with Mathlib	Formal proofs
WolframScript	12+	Symbolic verification

Optional (soft-imported): QuTiP, OQuPy, Kwant, PythTB, MEEP, OpenFermion, PySCF, Psi4, Astropy, TenPy, Cirq, PennyLane, EinsteinPy.

Citing

@software{entropic_time,
  author  = {Garcia-Gonzalez, Jorge A.},
  title   = {entropic-time: A Multiphysics Framework for Complex Action Theory
             with Entropic Proper Time},
  year    = {2026},
  url     = {https://github.com/jagg-ix/entropic-time}
}

Contributing

Bug reports and feature requests via GitHub Issues.