dlvt 2.0.1__tar.gz

dlvt-2.0.1/.gitignore

@@ -0,0 +1,88 @@
+# Python .gitignore
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Generated figures and outputs
+figures/*.pdf
+figures/*.png
+
+# Distribution artifacts
+dist/
+*.whl

dlvt-2.0.1/CONTRIBUTING.md

@@ -0,0 +1,125 @@
+# Contributing to DLVT
+
+Thank you for your interest in contributing to the Dynamic Leadership Vitality Theory project!
+
+## Code of Conduct
+
+Be respectful and collaborative. We're building a scientific tool for everyone.
+
+## Getting Started
+
+### 1. Clone and Install
+
+```bash
+git clone https://github.com/wbendinelli/dlvt.git
+cd dlvt
+pip install -e ".[dev]"
+```
+
+### 2. Create a Branch
+
+```bash
+git checkout -b feature/your-feature-name
+```
+
+## Development Guidelines
+
+### Code Style
+
+- Follow [PEP 8](https://www.python.org/dev/peps/pep-0008/)
+- Use [Black](https://black.readthedocs.io/) for formatting:
+  ```bash
+  black dlvt/ scripts/
+  ```
+
+### Documentation
+
+- All functions must have docstrings (NumPy style)
+- Include parameter descriptions, return types, and examples
+- Link to relevant paper equations/theorems
+
+### Testing
+
+- Write unit tests for new functions
+- Run tests before submitting:
+  ```bash
+  pytest
+  ```
+
+## Pull Request Process
+
+1. **Create a feature branch** with a descriptive name
+2. **Make your changes** with clear, atomic commits
+3. **Update documentation** if API changes
+4. **Test thoroughly** — especially on edge cases
+5. **Submit a pull request** with a clear description
+
+## Reporting Bugs
+
+Create a GitHub issue with:
+- **Title**: Clear, concise summary
+- **Description**: What you observed vs. expected behavior
+- **Steps to reproduce**: Minimal code example
+- **Environment**: Python version, OS, installed versions
+
+## Suggesting Features
+
+Open an issue with:
+- **Title**: Feature request — [your idea]
+- **Description**: What problem does it solve?
+- **Example usage**: How would users interact with it?
+- **Related work**: Any similar tools or papers
+
+## Paper References
+
+When modifying model equations, always cite the relevant theorem/proposition:
+
+```python
+def my_function():
+    """
+    Description.
+
+    References
+    ----------
+    Theorem 1 — [brief summary]
+    Proposition 2 — [brief summary]
+    """
+```
+
+## File Structure Guidelines
+
+```
+dlvt/
+├── __init__.py      # Public API exports
+├── model.py         # Core ODE system (NEVER modify parameter defaults without discussion)
+├── analysis.py      # Equilibrium, bifurcation analysis
+└── figures.py       # Publication figure generation
+
+scripts/
+├── run_all_figures.py                  # Master script
+├── fig8_bifurcation_hysteresis.py     # Extended analysis
+├── fig9_robustness.py
+└── fig10_intervention_comparison.py
+```
+
+## Default Parameters
+
+The parameter set in `dlvt.model.DEFAULT_PARAMS` is tied to the published paper results. **Do not modify without:**
+1. Updating the paper citation
+2. Regenerating all figures
+3. Notifying the author
+
+## Adding New Figures
+
+1. Create a function `figN(output_dir='figures/')` in `dlvt/figures.py` (for Figures 1–7)
+2. Or create a standalone script in `scripts/figN_*.py` (for Figures 8+)
+3. Add entry to `FIGURES` dict in `scripts/run_all_figures.py`
+4. Ensure output saved as `{output_dir}/figN_{name}.png` and `.pdf`
+
+## Questions?
+
+Open a discussion on GitHub or contact the author.
+
+## License
+
+All contributions are licensed under the MIT License (see LICENSE file).

dlvt-2.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 William Bendinelli
+
+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. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dlvt-2.0.1/PKG-INFO

@@ -0,0 +1,286 @@
+Metadata-Version: 2.4
+Name: dlvt
+Version: 2.0.1
+Summary: Dynamic Leadership Vitality Theory: A dynamical systems model of executive sustainability
+Home-page: https://github.com/wbendinelli/dlvt
+Author: William Bendinelli
+Author-email: William Bendinelli <wbendinelli@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/wbendinelli/dlvt
+Project-URL: Documentation, https://github.com/wbendinelli/dlvt#readme
+Project-URL: Repository, https://github.com/wbendinelli/dlvt
+Project-URL: Bug Tracker, https://github.com/wbendinelli/dlvt/issues
+Project-URL: Paper, https://papers.ssrn.com/sol3/papers.cfm?abstract_id=6455001
+Project-URL: Changelog, https://github.com/wbendinelli/dlvt/blob/main/CHANGELOG.md
+Keywords: dynamical-systems,leadership,executive,burnout,complexity,ode,bifurcation,computational-social-science,zombie-leader,vitality
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Sociology
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.10
+Requires-Dist: matplotlib>=3.7
+Provides-Extra: dev
+Requires-Dist: jupyter>=1.0; extra == "dev"
+Requires-Dist: ipykernel>=6.0; extra == "dev"
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: black>=22.0; extra == "dev"
+Requires-Dist: build>=0.10; extra == "dev"
+Requires-Dist: twine>=4.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Dynamic Leadership Vitality Theory (DLVT) — Python Package
+
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![Tests](https://img.shields.io/badge/tests-38%20passed-brightgreen.svg)](#running-the-tests)
+[![MIT License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+**Author:** William Bendinelli
+**Paper:** *Dynamic Leadership Vitality Theory: A Formal Model of the Zombie-Leader Equilibrium*
+**Target Journal:** *The Leadership Quarterly* (2026)
+
+---
+
+## Overview
+
+This package implements the **Dynamic Leadership Vitality Theory (DLVT)** model — a two-dimensional autonomous dynamical system that formalizes how leaders who accumulate career capital simultaneously generate the organizational complexity that drains the vitality they need to deploy it.
+
+The model predicts a single robust attractor: a **zombie-leader equilibrium** at $(V^{*} \approx 4.7,\; C^{*} \approx 32)$ in which the leader retains authority and reputation but permanently lacks the energetic bandwidth for strategic work. The zombie equilibrium is globally asymptotically stable (proved via Bendixson–Dulac + Poincaré–Bendixson on a trapping rectangle).
+
+**Three outcome regimes** emerge from the parameter space:
+
+- **Sustainable** — the leader reaches equilibrium with $V^{*} > V_{\mathrm{strategic}}$
+- **Zombie** — the leader converges to $V^{*} < V_{\mathrm{strategic}}$ (the default attractor)
+- **Collapse-Prone** — unsustainable trajectory where burnout is inevitable
+
+## Quick Start
+
+### Installation
+
+```bash
+git clone https://github.com/wbendinelli/dlvt.git
+cd dlvt
+pip install -e .
+```
+
+**Requirements:** Python ≥ 3.8, NumPy ≥ 1.24, SciPy ≥ 1.10, Matplotlib ≥ 3.7
+
+### Basic Usage
+
+```python
+from dlvt import make_params, simulate
+from dlvt.analysis import find_interior_equilibria, carrying_capacity
+
+# Create parameter set (defaults match Table 1 of the paper)
+p = make_params()
+
+# Simulate from initial state (V₀=8.0, C₀=5.0) over T=120 time units
+t, V, C, O, I, G = simulate(p, V0=8.0, C0=5.0, T=120)
+# V — vitality, C — career capital, O — complexity, I — impact, G — depletion ratio
+
+# Find equilibria and classify stability
+equilibria = find_interior_equilibria(p)
+for eq in equilibria:
+    status = "stable" if eq['stable'] else "unstable"
+    print(f"V*={eq['V']:.2f}, C*={eq['C']:.2f} ({status})")
+
+# Maximum sustainable career capital (Proposition 3)
+C_max = carrying_capacity(p)
+print(f"Carrying capacity: C*_max = {C_max:.2f}")
+```
+
+### Scenario Analysis
+
+```python
+from dlvt import make_params, simulate
+from dlvt.analysis import classify_regime
+
+# What happens if we increase recovery support?
+p_high_R = make_params(R=5.0)
+regime = classify_regime(p_high_R)
+print(f"Regime with R=5.0: {regime}")
+
+# What if complexity coupling is halved?
+p_low_beta = make_params(beta=0.125)
+t, V, C, O, I, G = simulate(p_low_beta, V0=8.0, C0=5.0, T=200)
+print(f"Final V={V[-1]:.2f}, C={C[-1]:.2f}")
+```
+
+## The Dynamical System
+
+The DLVT model is governed by two coupled ODEs:
+
+$$\frac{dV}{dt} = R \left(1 - \frac{V}{V_{\max}}\right) - \delta \cdot O^{\gamma} \cdot \frac{V}{V + \varepsilon}$$
+
+$$\frac{dC}{dt} = \alpha \cdot I - \mu \cdot C$$
+
+with derived quantities:
+
+- **Organisational Complexity:** $O(t) = O_0 + \beta \cdot C(t)^{\eta}$
+- **Leadership Impact:** $I(t) = C \cdot V \,/\, (1 + \phi \cdot O)$ — energy-gated effectiveness
+- **Depletion Ratio:** $\Gamma(t) = \delta \cdot O^{\gamma} \,/\, R$ — net drain when $\Gamma > 1$
+
+The first equation balances bounded vitality recovery against complexity-driven drain. The second models career capital accumulation through impact feedback minus depreciation. The smooth barrier $V/(V+\varepsilon)$ ensures positive invariance of the state space.
+
+## Parameter Table
+
+All parameters from **Table 1** of the paper (baseline calibration, $C_0 = 5.0$):
+
+| Symbol | Key | Default | Description |
+|:------:|:---:|:-------:|:------------|
+| $R$ | `R` | 3.0 | Vitality recovery rate |
+| $V_{\max}$ | `Vmax` | 10.0 | Maximum vitality capacity |
+| $\delta$ | `delta` | 0.02 | Energetic cost coefficient |
+| $\gamma$ | `gamma` | 2.0 | Complexity exponent in drain |
+| $O_0$ | `O0` | 1.0 | Baseline organisational complexity |
+| $\beta$ | `beta` | 0.25 | Capital–complexity coupling |
+| $\eta$ | `eta` | 1.0 | Capital scaling exponent |
+| $\alpha$ | `alpha` | 0.1 | Capital accumulation rate |
+| $\phi$ | `phi` | 0.15 | Complexity–impact suppression |
+| $\mu$ | `mu` | 0.2 | Capital depreciation rate |
+| $\varepsilon$ | `eps` | 0.1 | Smooth barrier regularisation |
+
+## Key Theoretical Results
+
+**Theorem 1 (Finite-Time Depletion):** Under exogenous complexity growth that creates a persistent deficit ($\Gamma > 1$), vitality reaches the $\varepsilon$-neighborhood of zero in finite time.
+
+**Theorem 2 (Global Asymptotic Stability):** The zombie equilibrium $(V^{*}, C^{*})$ is the unique interior attractor. Proved via Bendixson–Dulac (no closed orbits), trapping rectangle $[0, V_{\max}] \times [0, C_{\max}]$, and Poincaré–Bendixson.
+
+**Lemma 2 (Scope Absorption):** $V^{*}(\beta) \equiv V^{*}_0$ for all $\beta$ in the structurally interior region; the invariant $\beta C^{*} \approx 8.008$ is preserved. Scope reduction alone does not raise equilibrium vitality.
+
+**Proposition 3 (Carrying Capacity):** $C^{*}_{\max} = \left[\left(R/\delta\right)^{1/\gamma} - O_0\right]^{1/\eta} / \beta$
+
+## API Reference
+
+### `dlvt.model` — Core ODE System
+
+```python
+from dlvt import make_params, simulate, complexity, impact
+```
+
+| Function | Description |
+|:---------|:------------|
+| `make_params(**overrides)` | Create parameter dict with keyword overrides |
+| `complexity(C, p)` | $O = O_0 + \beta C^{\eta}$ |
+| `impact(V, C, O, p)` | $I = CV/(1 + \phi O)$ |
+| `dlvt_system(t, y, p)` | ODE right-hand side for `scipy.integrate.solve_ivp` |
+| `dlvt_exogenous(t, y, p, C_func)` | Variant with exogenous career capital path |
+| `simulate(p, V0, C0, T, max_step)` | Integrate ODE; returns `(t, V, C, O, I, G)` |
+
+### `dlvt.analysis` — Equilibrium Theory & Stability
+
+```python
+from dlvt.analysis import (
+    find_interior_equilibria, carrying_capacity,
+    jacobian_eigenvalues, is_zombie, classify_regime, regime_map
+)
+```
+
+| Function | Description |
+|:---------|:------------|
+| `find_interior_equilibria(p)` | Find all $(V^{*}, C^{*}) > 0$ fixed points |
+| `carrying_capacity(p)` | Maximum sustainable capital $C^{*}_{\max}$ |
+| `jacobian_eigenvalues(V, C, p)` | Eigenvalue structure and stability class |
+| `is_zombie(V, p)` | Check $V^{*} < V_{\mathrm{strategic}}$ |
+| `classify_regime(p)` | Returns `'sustainable'`, `'zombie'`, or `'collapse-prone'` |
+| `regime_map(betas, deltas)` | $(\beta, \delta)$ regime classification grid |
+
+### `dlvt.figures` — Publication Figure Generation
+
+```python
+from dlvt.figures import fig1, fig2, fig3, fig4, fig5, fig6, fig7
+
+fig3(output_dir='figures/')  # Phase portrait
+```
+
+| Figure | Content |
+|:-------|:--------|
+| Fig 1 | Temporal evolution of $V(t)$, $C(t)$, $O(t)$, $\Gamma(t)$ |
+| Fig 2 | Three outcome scenarios (sustainable, zombie, collapse) |
+| Fig 3 | Phase portrait with nullclines and equilibria |
+| Fig 4 | Bifurcation diagrams: $C^{*}$ and $V^{*}$ vs $\beta$, $R$ |
+| Fig 5 | Impact comparison: DLVT vs Human Capital Theory (Becker) |
+| Fig 6 | Carrying capacity heatmap $C^{*}_{\max}(\beta, R)$ |
+| Fig 7 | Regime map in $(\beta, \delta)$ space |
+
+## Reproducing All Paper Figures
+
+```bash
+python3 scripts/run_all_figures.py             # All 10 figures (PDF + PNG)
+python3 scripts/run_all_figures.py --fig 1-7   # Core only
+python3 scripts/run_all_figures.py --fig 8-10  # Extended analysis only
+```
+
+Extended figures (standalone scripts):
+
+```bash
+python3 scripts/fig8_bifurcation_hysteresis.py    # Hysteresis detection
+python3 scripts/fig9_robustness.py                # Structural robustness
+python3 scripts/fig10_intervention_comparison.py   # Recovery vs redesign
+```
+
+## Running the Tests
+
+```bash
+pytest tests/ -q          # 38 tests, all must pass
+pytest tests/ -v --tb=short  # verbose with tracebacks
+```
+
+The test suite pins every numerical claim in the paper (equilibrium values, carrying capacity, scope-absorption invariant, eigenvalue signs, basin-of-attraction convergence) so that any code change that breaks paper–code consistency is caught immediately.
+
+## Project Structure
+
+```
+dlvt/
+├── dlvt/                     # Core package
+│   ├── __init__.py           # Public API exports
+│   ├── model.py              # ODE system, parameters, integration
+│   ├── analysis.py           # Equilibria, stability, bifurcation, regimes
+│   └── figures.py            # Publication figures 1–7
+├── tests/                    # 38 pinning tests
+│   ├── test_model.py         # Model numerics, simulation, positive invariance
+│   └── test_analysis.py      # Equilibria, carrying capacity, regimes
+├── scripts/                  # Figure generation (8–10) and robustness grid
+├── figures/                  # Generated output (PDF + PNG)
+├── pyproject.toml            # Package metadata and dependencies
+├── setup.py                  # Legacy installer
+└── LICENSE                   # MIT
+```
+
+## Citation
+
+```bibtex
+@article{bendinelli2026dlvt,
+  title   = {Dynamic Leadership Vitality Theory:
+             A Formal Model of the Zombie-Leader Equilibrium},
+  author  = {Bendinelli, William},
+  year    = {2026},
+  note    = {Manuscript submitted to The Leadership Quarterly}
+}
+```
+
+## License
+
+MIT License — see [LICENSE](LICENSE) for details.
+
+Copyright 2026 William Bendinelli
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Issues, feature requests, and pull requests are welcome.

dlvt-2.0.1/QUICKSTART.md

@@ -0,0 +1,178 @@
+# Quick Start Guide — DLVT
+
+Get started with the Dynamic Leadership Vitality Theory model in 5 minutes.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+Or just install dependencies:
+
+```bash
+pip install numpy scipy matplotlib
+```
+
+## 1. Run a Simulation
+
+```python
+from dlvt import make_params, simulate
+import matplotlib.pyplot as plt
+
+# Create parameters (defaults from Table 1 of paper)
+p = make_params()
+
+# Simulate a leader's trajectory over 120 time units
+t, V, C, O, I, G = simulate(p, V0=8.0, C0=0.5, T=120)
+
+# Plot vitality and capital
+fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 6))
+ax1.plot(t, V, 'b-', label='Vitality V(t)')
+ax1.axhline(p['Vmax']/2, color='r', linestyle='--', alpha=0.5, label='Strategic threshold')
+ax1.set_ylabel('V(t)')
+ax1.legend()
+
+ax2.plot(t, C, 'g-', label='Career Capital C(t)')
+ax2.set_xlabel('Time')
+ax2.set_ylabel('C(t)')
+ax2.legend()
+
+plt.tight_layout()
+plt.show()
+```
+
+## 2. Find Equilibrium Points
+
+```python
+from dlvt import make_params
+from dlvt.analysis import find_interior_equilibria, carrying_capacity
+
+p = make_params()
+
+# Find all equilibria
+equilibria = find_interior_equilibria(p)
+print(f"Found {len(equilibria)} equilibrium point(s):")
+for i, eq in enumerate(equilibria):
+    print(f"  Eq {i+1}: V* = {eq['V']:.3f}, C* = {eq['C']:.3f}, stable = {eq['stable']}")
+
+# Maximum sustainable capital
+C_max = carrying_capacity(p)
+print(f"\nCarrying capacity: C*_max = {C_max:.2f}")
+```
+
+## 3. Compare Parameters
+
+```python
+from dlvt import make_params, simulate
+
+# Default parameters
+p_default = make_params()
+
+# Higher capital-complexity coupling (more burden per unit capital)
+p_high_beta = make_params(beta=0.5)
+
+# Simulate both
+t1, V1, C1, *_ = simulate(p_default, T=120)
+t2, V2, C2, *_ = simulate(p_high_beta, T=120)
+
+# Compare final vitality
+print(f"Beta=0.25: V(120) = {V1[-1]:.2f}")
+print(f"Beta=0.50: V(120) = {V2[-1]:.2f}")
+```
+
+## 4. Generate All Figures
+
+```bash
+python3 scripts/run_all_figures.py
+```
+
+Figures 1–10 are saved to `figures/` in both PNG and PDF formats.
+
+Selective figures:
+
+```bash
+# Core results only (Figures 1–7)
+python3 scripts/run_all_figures.py --fig 1-7
+
+# Extended analysis (Figures 8–10)
+python3 scripts/run_all_figures.py --fig 8-10
+
+# Specific figures
+python3 scripts/run_all_figures.py --fig 1,3,5
+```
+
+## 5. Classify Leadership Regime
+
+```python
+from dlvt import make_params
+from dlvt.analysis import classify_regime, is_zombie
+
+p = make_params()
+regime = classify_regime(p)
+print(f"Regime: {regime}")  # 'sustainable', 'zombie', or 'collapse'
+
+# Check if equilibrium is "zombie" (exhausted)
+p_zombie = make_params(beta=0.8)
+regime2 = classify_regime(p_zombie)
+print(f"High-complexity regime: {regime2}")
+```
+
+## Key Concepts
+
+| Symbol | Meaning |
+|--------|---------|
+| **V(t)** | Subjective vitality (energy available) — range [0, V_max] |
+| **C(t)** | Career capital (skills, status, relational capital) |
+| **O(t)** | Organisational complexity driven by capital growth |
+| **I(t)** | Leadership impact (effectiveness) — suppressed by complexity |
+| **Γ(t)** | Depletion ratio (Γ > 1 means net drain; Γ < 1 means recovery) |
+
+## Parameter Defaults (Table 1, Paper)
+
+| Parameter | Value | Meaning |
+|-----------|-------|---------|
+| R | 3.0 | Vitality recovery rate |
+| V_max | 10.0 | Maximum vitality capacity |
+| δ | 0.02 | Energetic cost of complexity |
+| γ | 2.0 | Complexity exponent in drain |
+| O₀ | 1.0 | Baseline irreducible complexity |
+| β | 0.25 | Capital-complexity coupling |
+| η | 1.0 | Capital scaling exponent |
+| α | 0.1 | Capital accumulation rate |
+| φ | 0.15 | Impact suppression by complexity |
+| μ | 0.2 | Capital depreciation rate |
+| ε | 0.1 | Regularization (ε → 0 in theory) |
+
+## The Two-Equation System
+
+The DLVT model integrates two dynamics:
+
+```
+Recovery:   dV/dt = R·(1 − V/Vmax)
+Drain:      dV/dt − δ·O^γ · V/(V + ε)
+
+Capital:    dC/dt = α·I − μ·C
+            where I = C·V / (1 + φ·O)
+```
+
+**Recovery** is logistic (saturation). **Drain** is nonlinear in complexity. Capital accumulates through impact (which depends on energy) and decays naturally.
+
+## Three Outcome Regimes
+
+1. **Sustainable**: Equilibrium with high vitality and manageable capital
+2. **Zombie**: Chronic exhaustion at low vitality; capital still accumulates but impact is suppressed
+3. **Collapse**: No equilibrium; vitality crashes to zero
+
+## Next Steps
+
+- Read `README.md` for full API reference
+- Explore `notebooks/` for interactive examples
+- See `CONTRIBUTING.md` for how to extend the model
+- Consult the paper for theoretical details
+
+## Questions?
+
+- Check existing GitHub issues
+- Review docstrings: `help(dlvt.simulate)`
+- Open a new issue with your question