Metadata-Version: 2.4
Name: quiverlab
Version: 1.0.0
Summary: Exact representation theory of quivers with relations, for algebraists: modules and AR theory, resolutions, Ext-algebras, Hochschild and cyclic (co)homology, invariants
Author-email: Marco Armenta <drmarcoarmenta@gmail.com>
License-Expression: MIT
Project-URL: Homepage, https://marcoarmenta.github.io/quiverlab/
Project-URL: Documentation, https://marcoarmenta.github.io/quiverlab/
Project-URL: Repository, https://github.com/MarcoArmenta/quiverlab
Project-URL: Issues, https://github.com/MarcoArmenta/quiverlab/issues
Project-URL: Changelog, https://github.com/MarcoArmenta/quiverlab/blob/main/CHANGELOG.md
Keywords: quiver,path algebra,Hochschild cohomology,Gerstenhaber bracket,representation theory,homological algebra,exact arithmetic
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Science/Research
Classifier: Topic :: Scientific/Engineering :: Mathematics
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Operating System :: OS Independent
Classifier: Typing :: Typed
Requires-Python: >=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: numpy>=1.21
Requires-Dist: sympy>=1.12
Requires-Dist: matplotlib>=3.7
Provides-Extra: fast
Requires-Dist: numba>=0.64; extra == "fast"
Provides-Extra: hpc
Requires-Dist: pyyaml>=6; extra == "hpc"
Provides-Extra: web
Requires-Dist: fastapi>=0.115; extra == "web"
Requires-Dist: uvicorn[standard]>=0.30; extra == "web"
Requires-Dist: jinja2>=3.1; extra == "web"
Requires-Dist: python-ulid>=2.7; extra == "web"
Requires-Dist: pydantic>=2.7; extra == "web"
Provides-Extra: qpa
Requires-Dist: passagemath-gap[qpa]>=10.8; sys_platform != "win32" and extra == "qpa"
Provides-Extra: docs
Requires-Dist: mkdocs-material>=9.5; extra == "docs"
Requires-Dist: mkdocstrings[python]>=0.26; extra == "docs"
Requires-Dist: mkdocs-jupyter>=0.25; extra == "docs"
Requires-Dist: mkdocs-gen-files>=0.5; extra == "docs"
Requires-Dist: mkdocs-literate-nav>=0.6; extra == "docs"
Requires-Dist: mkdocs-section-index>=0.3; extra == "docs"
Requires-Dist: mike>=2.1; extra == "docs"
Provides-Extra: dev
Requires-Dist: pytest>=8; extra == "dev"
Requires-Dist: build>=1.2; extra == "dev"
Requires-Dist: twine>=5.1; extra == "dev"
Requires-Dist: httpx>=0.27; extra == "dev"
Dynamic: license-file

# QuiverLab

[![CI](https://github.com/MarcoArmenta/quiverlab/actions/workflows/ci.yml/badge.svg)](https://github.com/MarcoArmenta/quiverlab/actions/workflows/ci.yml)
[![Docs](https://github.com/MarcoArmenta/quiverlab/actions/workflows/docs.yml/badge.svg)](https://marcoarmenta.github.io/quiverlab/)
[![Tests](https://img.shields.io/badge/tests-5338_oracle--pinned-brightgreen)](https://marcoarmenta.github.io/quiverlab/verification/)
[![PyPI](https://img.shields.io/pypi/v/quiverlab.svg)](https://pypi.org/project/quiverlab/)
[![Python](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue)](https://github.com/MarcoArmenta/quiverlab/blob/main/pyproject.toml)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
<!-- [![DOI](https://joss.theoj.org/papers/<id>/status.svg)](https://doi.org/<doi>) -->

# **Exact representation theory of quivers with relations, for algebraists** 
Modules and Auslander–Reiten theory, resolutions, Ext-algebras and Koszulity,
Hochschild (co)homology with its calculus (cup, Gerstenhaber, cap, Connes), cyclic homology, and
Cartan/Coxeter/spectral invariants, all exactly.

## ⬇️ DOWNLOAD APPLICATION HERE

> ### **[⬇ Download the QuiverLab app](https://github.com/MarcoArmenta/quiverlab/releases/tag/app-latest)** — one file, no install, no code.
>
> Double-click it and the GUI opens in your browser: draw a quiver, pick a
> field, read exact results. Fully offline.
>
> | OS | Download |
> |---|---|
> | **macOS** (Apple Silicon: M1–M4) | [QuiverLab-macos-arm64.zip](https://github.com/MarcoArmenta/quiverlab/releases/download/app-latest/QuiverLab-macos-arm64.zip) |
> | **Windows** | [QuiverLab-windows.exe](https://github.com/MarcoArmenta/quiverlab/releases/download/app-latest/QuiverLab-windows.exe) |
> | **Linux** (x86-64) | [QuiverLab-linux-x86_64.tar.gz](https://github.com/MarcoArmenta/quiverlab/releases/download/app-latest/QuiverLab-linux-x86_64.tar.gz) |
>
> First-open notes (the app is not code-signed yet, so each OS warns **once**):
> 
> **macOS** — unzip and double-click; when the *"Apple could not verify…"*
> dialog appears click **Done** (not "Move to Trash"), then System Settings →
> Privacy & Security → scroll to Security → **Open Anyway** → Open. (Terminal
> alternative: `xattr -d com.apple.quarantine ./QuiverLab`.)
>
> **Windows** — if
> SmartScreen appears, choose *More info* → *Run anyway*.
>
> **Linux** — `tar xzf`,
> then run `./QuiverLab`.
>
> **Intel Mac** — no one-file build (GitHub retired its
> Intel-mac builders); use
> `docker run -p 8000:8000 ghcr.io/marcoarmenta/quiverlab:latest gui`
> or the [pip path](https://marcoarmenta.github.io/quiverlab/offline-app/).


## The two metagoals

QuiverLab is built toward two long-term goals, and every release is measured
against them:

1. **No code required.** Every computation the library can do should be
   reachable without writing a single line of code: draw the quiver and the
   relations in the browser GUI, specify modules entry-by-entry in the no-code
   panel, export a config file for a cluster, and read the results as rendered
   mathematics (or a PDF report). Python is a power-user option, never a
   prerequisite.
2. **Any computation done in representation theory.** The aim is that whatever
   a representation theorist of finite-dimensional algebras computes in a paper
   — homological invariants, module-theoretic constructions, Auslander–Reiten
   data, Ext algebras, spectral/Coxeter data, and beyond — can be computed
   here, exactly and with certified, oracle-tested results. The gap between
   this goal and the current surface is tracked openly as the coverage program
   in [`docs/plans/ROADMAP.md`](docs/plans/ROADMAP.md); if your computation is
   missing, it belongs on that list.

QuiverLab computes with finite-dimensional algebras `kQ/I` over the complex numbers
(exactly — no floating point, ever) and over all finite fields: certified
finite-dimensionality, Hochschild (co)homology with cup products and Gerstenhaber
brackets, the first full Chouhy–Solotar resolution, module Ext, and Cartan/Coxeter
invariants. Floats fail loudly by design.

### v0.2.0 coverage scorecard (C1–C8)

The [`ROADMAP.md`](docs/plans/ROADMAP.md) coverage program C1–C8 is delivered in
v0.2.0. Nothing here over-claims: where a computation is a semi-decision, a
verifier, or scope-limited, the surface says so and refuses loudly outside it.

| Coverage phase | Delivered by | Honest scope |
|---|---|---|
| **C1** Categorical glue (Hom bases, Krull–Schmidt) | P37 + P30 (Krull–Schmidt splitter, pre-v0.2.0) | char-p decomposition refuses loudly past the exact-locality budget |
| **C2** Forms, roots, structural recognition | P38 | per-flag honest recognizers (never a silent `False`); Dynkin/Euclidean detection is hereditary |
| **C3** Auslander–Reiten theory completed | P41 | AR-knitting semi-decides rep-finiteness — budget-capped, loud when uncertified |
| **C4** τ-tilting engine + live fan | P45 | brick labels iso-class-certified with loud refusal; enumeration complete iff τ-tilting-finite (budget-capped); fan drawn for n = 2, 3 |
| **C5** Gentle / string subsystem | P46, P48 | AAG is an invariant, not a complete classifier; surfaces are unpunctured-with-boundary v1 (P48 refuses punctured/closed/self-folded) |
| **C6** Homological-dimensions family | P40 | certified value or honest bound, never a bare number; `is_gorenstein` three-valued |
| **C7** Tilting & new-algebra constructions | P44 | verifiers, not deciders (`tilting_check`); Gabriel-quiver recovery refuses loudly |
| **C8** Geometry, derived fingerprints, complexes | P39, P42, P43, P49 | canonical decomposition Dynkin-hereditary-only; derived fingerprint is a *necessary-condition* comparison (a verifier, not a decider); Voigt codimension is an upper bound on `kQ/I` |

Two v0.2.0 plans sit beside the C-program: **P36** adds Macaulay2 as a fifth
external oracle class, and **P47** delivers quasi-hereditary algebras and
recollements. Every row's oracles and honest-scope notes are on the
[verification page](https://marcoarmenta.github.io/quiverlab/verification/).

## Get QuiverLab

Most users want one of these, in this order:

**1. Download the desktop app** — one file, double-click it, and the zero-code
GUI opens in your browser on localhost, fully offline, using your machine's
real cores and RAM. Grab the binary for your OS from the
[**download box at the top of this page**](#️-download-application-here)
(macOS / Windows / Linux), which also carries the one-time first-open steps for
the unsigned binaries.

**2. Download the containerized application** — one image, the full exact
engine, no Python setup (registry paths are lowercase-only):

```bash
docker pull ghcr.io/marcoarmenta/quiverlab:latest      # or: apptainer pull quiverlab.sif docker://ghcr.io/marcoarmenta/quiverlab:latest
docker run --rm -p 8000:8000 ghcr.io/marcoarmenta/quiverlab:latest gui
# open http://localhost:8000 — the zero-code GUI, fully offline, using your
# machine's cores and RAM. The same image runs batch configs; see
# "Writing and running config files" below.
```

**3. Clone the repo and build the container yourself:**

```bash
git clone https://github.com/MarcoArmenta/quiverlab.git && cd quiverlab
docker build -f container/Dockerfile -t quiverlab:local .
docker run --rm -p 8000:8000 quiverlab:local gui
```

**4. Use the web interface** — the self-hostable server tier (`webapp/`):
instant answers for small examples, queued jobs with permalinks for deep ones,
and a shared exact-result cache — see [Web interface](#web-interface).

**5. Prefer code?** - Python-library installs and SLURM clusters are covered
[at the bottom](#install-the-python-library).

## Three lines to a Hochschild table

```python
from quiverlab import Quiver, CC

Q = Quiver(vertices=[1, 2, 3], arrows={"a": (1, 2), "b": (2, 3), "c": (1, 3)})
print(Q.algebra(relations=["a*b"], field=CC).hochschild_cohomology(3))
```

## Learn more

- **Documentation:** <https://marcoarmenta.github.io/quiverlab/>
- **Tutorials:** [executable notebooks](docs/tutorials/) — start here.
- **Under the hood:** [internals chapters](docs/internals/) — how each number is produced.
- **No-code interfaces:** the containerized app ships an offline GUI (`quiverlab-hpc gui`), and the self-hostable server tier (`webapp/`) adds queued and email-verified big jobs — see [Web interface](#web-interface).
- **Cite:** see the JOSS paper (`paper/paper.md`) and [`CITATION.cff`](CITATION.cff).

## The classic characteristic pathology, in one loop

```python
from quiverlab import truncated_polynomial, CC, GF

for field in (CC, GF(2), GF(3)):
    print(field, truncated_polynomial(2, field=field).hochschild_cohomology(4).dims)
# CC     [2, 1, 1, 1, 1]
# GF(2)  [2, 2, 2, 2, 2]
# GF(3)  [2, 1, 1, 1, 1]
```

## General quivers with relations (kQ/I)

```python
from quiverlab import Quiver, CC

Q = Quiver(vertices=[1, 2, 3, 4],
           arrows={"a": (1, 2), "b": (2, 4), "c": (1, 3), "d": (3, 4)})
A = Q.algebra(relations=["a*b - c*d"], field=CC)   # commutative square, exact
print(A.dim)                                        # 9
print(A.hochschild_cohomology(1))                   # HH^0 = 1  HH^1 = 0
```

Non-monomial relations are completed with an exact noncommutative Gröbner
(Buchberger–Mora overlap) engine and certified finite-dimensional; a
non-admissible or infinite presentation fails loudly with `AdmissibilityError`
or `NotFiniteDimensionalError`, never a hang.

## Modules and invariants

```python
from quiverlab import Quiver, CC

A = Quiver([1, 2, 3, 4], {"a": (1, 2), "b": (2, 4), "c": (1, 3), "d": (3, 4)}
           ).algebra(relations=["a*b - c*d"], field=CC)   # commutative square

S1, S4 = A.simple(1), A.simple(4)
A.projective(1).dimension_vector()      # {1: 1, 2: 1, 3: 1, 4: 1}
A.ext(S1, S4, 2)                        # 1     (Ext^2 of simples)
int(A.global_dimension())              # 2
A.loewy_length()                       # 3
A.simple(1).projective_resolution(4)   # P_1 <- P_2(+)P_3 <- P_4 <- 0
```

Every module is a right A-module over the stated exact field; Ext, Hom, and the
projective resolution are exact. Exact `spectral_radius`/`mahler_measure`, `center()`,
`complexity()` (a lower-bound estimate — can under-report, exact only on local /
single-vertex inputs), and `sweep()` (invariant × field) round out the invariant surface.

## Families and citations

```python
from quiverlab import NakayamaAlgebra, QuantumCI, families, bibliography

A = NakayamaAlgebra([3, 2, 2])          # cyclic Nakayama, dim 7
print(A.hochschild_cohomology(0))       # HH^0 = 1
print(A.citations())                    # ('nakayama', 'assem_book', 'bar')

print(families())                       # the whole v1 catalog with signatures
print(bibliography(A.citations()))      # grouped, annotated references
```

## How quiverlab is verified

Every shipped feature is unit tested (the suite is 5338 tests over the
`[dev,fast,docs,web,qpa,hpc]` extras), and the mathematics is pinned by **two classes
of oracle** — surfaced since Plan 32 as five orthogonal, runnable marker classes
(`oracle_literature` / `oracle_crossengine` / `oracle_selfcert` / `qpa` / `m2`), audited
against live collection:

- **Theory and literature, on constructed examples.** We build many algebras the
  literature (or a theorem we know) has already resolved and assert quiverlab
  reproduces the published value exactly — Happel's hereditary vanishing, the
  Buchweitz–Green–Madsen–Solberg / Bergh–Erdmann quantum complete intersection,
  the classical `k[x]/(x^n)` and Künneth commutative-CI values, and more. Where no
  single published vector is at hand we cross-check an *independent* path in the
  library and say so inline. The read-only hanlab bank supplies byte-level
  closed-form oracles.
- **Cross-engine and external agreement.** The bar complex, the minimal `A^e`,
  Bardzell, and Chouhy–Solotar resolutions are independent engines; where two
  overlap they must agree degreewise over the primes `{32003, 2, 3, 5}`. And
  wherever the GAP package **QPA** implements a feature we recompute with it and
  demand equality (`A.crosscheck(...)`). QPA does not implement everything
  quiverlab does; the docs page names exactly where it is used and which theory
  oracle stands in where it cannot. And a live **Macaulay2** bridge recomputes nc
  graded dimensions and commutative Ext data (single-vertex scope; `-m m2`) — a
  genuinely different computer-algebra system as a second external oracle.

Exactness is enforced structurally: an AST gate bans every float from `src/`, and
the entire deep suite runs twice in CI — once on the numba kernels, once on the
pure-Python path (`QUIVERLAB_NO_NUMBA=1`) — with the two required to agree exactly.
The full methodology, a subsystem → oracles → test-file table, the CI matrix, and
an honest-scope section live in **[How quiverlab is verified](https://marcoarmenta.github.io/quiverlab/verification/)**
(`docs/verification.md`).

## Status

Engine, module, and families phase (Plans 01–06 delivered, together with the
Plan-04 Chouhy–Solotar resolution). On top of the foundations — monomial presentations,
exact fields, bar-complex Hochschild (co)homology — the hanlab deep engine is now
ported and wired in:

- **A fast GF(p) engine** behind the field interface: `hochschild_cohomology`
  and `hochschild_homology` take `engine="auto" | "bar" | "fast"`. `auto` picks
  the numpy mod-p rank engine over prime fields and the exact bar path
  everywhere else; both agree exactly where both can run. The fast engine still
  builds the exponential bar basis, so it guards its depth loudly (raise
  `max_cells` deliberately) — the depth *unlock* lives in the resolutions below.
- **Deep monomial resolutions.** The minimal (Bardzell) and periodic bimodule
  resolutions reach degrees the bar complex never could — k[x]/(x^a) and cyclic
  Nakayama to depth 40 instantly — and certify structural facts (a finite global
  dimension shows up as vanishing generators), cross-checked exactly against the
  bar oracle over primes {32003, 2, 3, 5} on the overlap range.
- **The Chouhy–Solotar resolution** (`resolutions_cs`, `engine="cs"`). The
  domain-generic CS projective bimodule resolution for admissible kQ/I — its
  HH•/HH^• dimensions and representative (co)cycles reach Hochschild degrees the
  bar oracle cannot, with CS↔bar comparison maps; it specializes to Bardzell's
  minimal resolution on monomial algebras (operation transport is certified
  inside the bar-buildable window).
- **Tamarkin–Tsygan calculus**, as a public product surface: **cup/cap products,
  the Gerstenhaber bracket, and the induced Connes differentials** on `HH^•`/`HH_•`
  (`A.cup_products`, `A.cap_products`, `A.gerstenhaber_brackets`,
  `A.connes_differentials`) — exact structure-constant tables on the recorded HH
  basis, with worked-steps reports; plus **cyclic homology** (Connes' mixed complex).
  The **Gerstenhaber bracket goes native on the Chouhy–Solotar resolution — past the
  bar window, over any exact field** (Negron–Witherspoon / Volkov homotopy liftings),
  completing the TT calculus surface (cup and cap went native earlier).
- **HH¹ as a Lie algebra (R11).** The outer-derivation algebra `Der/Inn` with the
  commutator bracket over **any exact field** (`A.hh1_lie_structure` — derived /
  lower-central series, solvable / nilpotent / abelian / perfect, computed from the
  algebra's own structure constants, independent of the window-bounded bracket engine),
  and over **characteristic 0** the solvable radical, Levi decomposition, sl₂-count and
  toral rank behind a hard char gate; the `k[x]/(x^n)` **solvable-vs-Jacobson–Witt**
  dichotomy (`W₁` at `n = char = p`) and `HH¹(Kronecker) ≅ sl₂` (char ≠ 2), plus the
  RSS Ext-quiver solvability certificate — clickable in the no-code GUI.
- **HH• as a graded Lie module over HH¹ (R12).** The Gerstenhaber degree-1 action (the
  field-general Lie derivative `L_D f = D∘f − Σ f(…,Da_i,…)`, over any exact field —
  `A.hh_lie_module`), its weight/torus decomposition over **characteristic 0** and the
  indecomposable Lie-module summands; the Kronecker `HH¹(kK₂) ≅ sl₂` acting irreducibly
  on `HH^1` (the toupie adjoint `L(2)`), the `k[x]/(x^n)` truncated-Witt grading (a
  Virasoro-subquotient analogue) — clickable in the no-code GUI.
- **Hochschild (co)homology with arbitrary bimodule coefficients** (`D(A)`, twisted
  `{}_1A_ν`, `A/soc`, any no-code bimodule) and **relative HH over the vertices** —
  `coefficients=` on the Hochschild kinds, `relative_to="vertices"` for `HH_•(A|kQ₀,M)`.
- **Spectral sequences** — filtered & double complexes, exact `E_r` pages with
  canonical representatives + a convergence certificate (`E_∞` totals == total
  homology), and four presets (Cartan–Eilenberg change-of-rings, Grothendieck,
  radical filtration, Hochschild `(b, B)`); the `(b, B)` SS is clickable via
  `ss_hochschild`.
- **Invariants:** the integer **Cartan** matrix, the **Coxeter** matrix and its
  characteristic polynomial (all fields, exact via sympy); **Euler / Tits forms**
  with exact finite/tame/wild definiteness, orientation-blind **Dynkin/Euclidean
  type detection**, **positive-root** enumeration for Dynkin type, and the
  **structural recognizers** (`is_semisimple` … `is_gentle`, with a live QPA
  crosscheck); **Koszulity** and the Yoneda Ext-algebra clickable in the no-code
  GUI; and, over GF(p), the **Nakayama** automorphism with the **Frobenius** and
  **symmetric** tests (loud `FieldError` off a prime field).
- **Recognizer batteries (R34 + R35).** The **homological string-algebra test**
  (Suárez-Álvarez: among representation-finite algebras, string ⇔ the middle term of
  every extension of indecomposables has ≤ 2 summands — a three-valued semi-decision
  that is a *discriminating* oracle against the syntactic recognizer, raising loudly on
  a k̄-sound contradiction), and **toupie algebras** (`ToupieAlgebra` constructor +
  connected-acyclic graph-shape recognizer + the `a`-Kronecker `HH^• = [1, a²−1, 0, …]`
  closed form + the char-0 `sl_a ⊆ HH¹` inclusion), both clickable in the no-code GUI.
- **Modules, scalar invariants, and the exact spectral layer.** Right A-modules
  with exact **Ext**, **Hom**, and minimal **projective resolutions**; the scalar
  invariants **Loewy length**, **center**, and **complexity** (GF(p); the last a
  lower-bound estimate that can under-report, exact only on local / single-vertex
  inputs); and the
  exact **spectral radius** / **Mahler measure** of the Coxeter polynomial as
  sympy algebraic numbers — no floats, ever.
- **Certified Coxeter spectral analysis (R20).** `A.coxeter_spectral()` — the exact
  cyclotomic **Φ_n** factorization, a cyclotomic / quasi-unipotent verdict and the
  finite Coxeter **order** (Φ^m = I, verified by exact matrix power), the exact count
  of roots outside the unit circle, and the spectral radius & Mahler measure as
  **certified algebraic numbers** (minimal polynomial + rational isolating interval,
  never a float), with the class-conditional **Lehmer-class note** (documentation only).
- **Homological dimensions (C6).** Public **syzygy/cosyzygy** operators,
  **finitistic / dominant / Gorenstein dimensions**, the **Igusa–Todorov φ/ψ**
  functions, and **Ω/τ-periodicity certificates** — the C6 homological-dimensions
  family, each result carrying the `GlobalDimension`-style certified-value-or-honest-bound
  honesty (never a bare number when unresolved, `is_gorenstein` three-valued
  True/None), and clickable end-to-end via the no-code `homological_profile`.
- **Homological invariants II (C6, P53).** **φdim / ψdim as algebra invariants**
  (exact for representation-finite input via the ⊕-of-all-indecomposables theorem, a
  certified lower bound otherwise — never a claimed sup), the **φ-spectrum and its gaps**
  (Barrios–Mata–Rama), **Lat-Igusa-Todorov finitistic certificates** (a proof-carrying
  certified `findim` upper bound from a decidable family, or an honest "no known decision
  procedure"), and the **stable fractional Calabi–Yau dimension** of self-injective
  algebras (`S = Ω∘ν`, `Σ = Ω⁻¹`, Ivanov–Volkov, certified at the weak-on-generators
  tier) — clickable via `homological_profile` (new φdim/ψdim/spectrum/LIT rows) and the
  new `fractional_cy` compute kind.
- **Auslander–Reiten theory.** The AR translates τ / τ⁻ and the Nakayama functor
  ν / ν⁻ as named functors, **almost-split sequences** `0 → τM → E → M → 0` with the
  middle term built and certified (exact, non-split, indecomposable ends), irreducible
  maps and `rad(M,N)/rad²`, stable Hom, and **AR-quiver knitting** — complete for a
- **The radical filtration of `mod A` (Liu–Chaio, R37+R21).** Exact `rad^n(X,Y)`
  layer dimensions on the knitted indecomposables, the **nilpotency index** of
  `rad(mod A)`, and the `rad^∞ = 0 ⇔ representation-finite` (Auslander) certificate;
  **Liu's left/right degrees** of irreducible maps, sectional paths, the
  postprojective/preinjective/regular partition, directing modules and the
  **representation-directed** recognizer — the R21+R37 axis, certified on the
  representation-finite domain (self-injective input and rep-infinite windows refuse
  or label honestly), clickable via the no-code `radical_filtration` /
  `ar_invariants` kinds.
- **The persistence / TDA bridge (R33).** Barcodes as **interval decompositions** of
  `A_n` and zigzag persistence modules (Gabriel / Botnan–Crawley-Boevey; **field-robust
  over `GF(2)`** — interval modules are bricks), and **AR-quiver-indexed generalized
  persistence diagrams** for commutative ladders `CL(n) = A_n □ A_2` (`n ≤ 4`,
  representation-finite; Escolar–Hiraoka; `n ≥ 5` a loud refusal) — representation theory
  first, the `barcode` no-code compute kind. Exact only: the filtration parameter is the
  discrete vertex index (no float thresholds, no `∞`).
- **Skew group algebras `A⋊G` (R8).** A base `kQ/I` and an **explicit** finite group acting
  by quiver automorphisms build the smash product `A⋊G = A#kG` (dimension `|G|·dim A`,
  characteristic-agnostic) as a no-code **input** — with the **Ştefan conjugacy-class Hochschild
  decomposition** `HH^n(A⋊G) ≅ ⊕_{[g]} HH^n(A, {}_gA)^{Z(g)}` (over `char k ∤ |G|`)
  cross-checked degreewise against the direct engine.
- **Incidence algebras: `HH^*` IS the cohomology of the order complex (R9).** For a finite
  poset `P`, `HH^n(kP) = H^n(Δ(P); k)` (Gerstenhaber–Schack; Cibils for an arbitrary finite
  poset), computed on the *combinatorial* cochain complex of the nerve instead of the
  enveloping algebra — `A.incidence_cohomology(top)`, with a no-code **poset input mode**
  (type the cover relations, see the Hasse diagram, read `HH^*`). One exact **integer** Smith
  normal form answers **every characteristic at once** and says *why* they differ: `RP²`'s
  `H₁ = ℤ/2` is exactly what makes `HH^*(GF₂) = [1,1,1]` while `HH^*(QQ) = [1,0,0]`. The
  theorem's hypothesis is never guessed — an algebra without poset provenance refuses loudly.
- **Fast Koszul `HH` off the GHMS resolution (R10).** For a Koszul algebra, the
  comultiplicative minimal bimodule resolution `P_n = A ⊗_S K_n ⊗_S A` on the Koszul kernels
  `K_n` — `engine="ghms"` on both Hochschild methods, a third independent oracle class
  agreeing degreewise with the minimal-syzygy engine and with bar/CS. Koszulity is a **hard
  three-valued gate**: not-Koszul refuses *naming the `Ext`-algebra obstruction*, and
  "unknown" refuses too.
- **Generalized Koszulity beyond the quadratic case (R36).** The **internal
  (path-length) generation degrees** of `Ext•(k,k)`, read off the shipped minimal
  resolutions — the datum that distinguishes `k[x]/x³`, `k[x]/x⁴` and `k[x]/x⁵`, whose
  *homological* Yoneda generators are identical. On top of it: **Berger's N-Koszul**
  2-N alternation certificate (`δ(n)` reproduced exactly for `N = 2..5`),
  **Cassidy–Shelton K₂** decided through an *explicit certified window* (three-valued,
  honestly inconclusive beyond it, decisive `False` on a degree-≥3 Yoneda generator),
  and the **Brenner–Butler–King `(p,q)`-almost-Koszul** classifier, which labels exactly
  the algebras a Koszul route refuses — reproducing BBK's `(h−2, 2)` on the Dynkin
  preprojectives `Π(A₃)/Π(A₄)/Π(A₅)/Π(D₄)`. The quadratic case defers to the Plan-27
  verdict verbatim; multi-Koszul is offered only where Herscovich defines it
  (connected/local), refusing multi-vertex input with a pointer to K₂. Clickable as
  `koszul`.
- **Amiot–Keller cluster categories (R31).** The certified acyclic (Dynkin) slice:
  `#indec(C_Q) = #ind(mod kQ) + n` — the almost-positive roots — the cluster-tilting
  objects **as** support τ-tilting pairs (Adachi–Iyama–Reiten, so the shipped exchange
  graph IS the cluster exchange graph and its count IS the cluster number), the
  cluster-tilted End-algebra as a Jacobian algebra via Fomin–Zelevinsky mutation, and a
  2-Calabi–Yau certificate on the module window. Every count carries its provenance: an
  uncertified enumeration is refused with its reason, and a budget stop on a
  representation-FINITE algebra is never dressed up as infiniteness. Clickable via
  `cluster_category`.
- **Derived category.** Reified hyper-Hom classes `Hom_{D^b}(X, Y[n])` as actual
  chain maps, the derived AR translate `τ_{D^b} = ν∘[−1]` on perfect complexes (loud
  refusal at infinite global dimension, per Happel), a **tilting-complex verifier**
  (rigidity + K₀ generation) with `End(T)` recovered as the Rickard derived-equivalent
  algebra, and a **derived fingerprint** comparing algebras on Coxeter polynomial,
  Cartan (det + Smith), HH/HC and centre — in necessary-condition language only.
- **Gentle / string subsystem (C5).** String & band module classification
  (Butler–Ringel), string-module τ by the hook/cohook combinatorics, the
  Avella-Alaminos–Geiss derived invariant for gentle algebras (honest: an
  invariant, not complete), and a `BrauerGraphAlgebra` constructor from a ribbon
  graph — with the algebra-only `strings` no-code block (census + bands + rep-type
  + AG).
- **Skew-gentle algebras (R32).** The triple `(Q, I, Sp)` recognizer, the
  characteristic-free idempotent-split constructor `SkewGentleAlgebra` (He–Zhou–Zhu /
  Chen — dim-certified against the associated gentle algebra), special-string module
  re-gluing, support τ-tilting via the engine (the orbifold model as the cross-check
  oracle), and the brick-finite ⇔ representation-finite certificate (Demonet–Iyama–Jasso
  ∘ Garcia–Lavoué, char ≠ 2) — with the no-code `skew_gentle` block.
- **Tilting and constructions (C7).** tilting/cotilting + Bongartz completion,
  minimal add(M)-approximations, one-point extensions, repetitive slices,
  Jacobian algebras from a potential, and Gabriel-quiver recovery of any
  structural oracle) or refuses loudly; `tilting_check` is clickable in the no-code GUI.
- **Marked surfaces → gentle algebras (Plan 48).** Marked surfaces → ideal
  triangulations → gentle Jacobian algebras (Fomin–Shapiro–Thurston / Labardini /
  ABCP), with flip ↔ cluster mutation certified per instance — draw or pick a surface
  and get the algebra, a no-code *input* method absent from QPA (unpunctured-with-boundary
  v1; punctures/closed/self-folded refuse loudly).
- **Geometry of representations (C8, Kac/Voigt).** Orbit dimensions in the
  representation variety (`dim O_M = Σ d_v² − dim End(M)`), Voigt rigidity with an
  honest codimension (`= dim Ext¹(M,M)` on hereditary, an upper bound on `kQ/I`), the
  Kac canonical decomposition of a dimension vector (hereditary Dynkin, rigidity-
  certified per instance), and the Zwara–Bongartz degeneration / hom-order poset for
  representation-finite algebras — with `orbit_geometry` clickable in the no-code GUI.
- **Quasi-hereditary algebras and recollements.** Standard/costandard modules
  Δ(i)/∇(i), a quasi-heredity test (Dlab–Ringel, order-dependent), good-filtration
  multiplicities + BGG reciprocity, the characteristic tilting module and its Ringel
  dual, and recollements from an idempotent (the corner `eAe`, the quotient `A/AeA`,
  and the six functors) — each certified per instance or refusing loudly;
  `quasi_hereditary` is clickable in the no-code GUI. **White space in QPA.**
- **Fundamental group and simple connectivity (coverings).** The presentation
  fundamental group π₁(Q,I) with exact abelianization by ℤ Smith normal form, the
  Hurewicz `Hom(π₁,k⁺) ↪ HH¹` check, and a strongly-simply-connected recognizer (the
  separation condition, Skowroński) with a witness on failure — three-valued and
  honest per Adian–Rabin (`None` when undecidable); the intrinsic π₁ is refused loudly.
  Clickable via `fundamental_group` / `simply_connected`. **White space in QPA.**
- **τ-tilting engine (C4, Adachi–Iyama–Reiten).** Support τ-tilting pairs via
  mutation, the exchange graph + torsion-class lattice with brick labels, 2-term
  silting, King θ-stability, maximal green sequences, and the AIR four-way count
  identity (`#sτ-tilt = #f.f. torsion = #2-term silting = #semibricks = Catalan(n+1)`
  for `kA_n`) — every enumeration budget-capped with the honest
  complete-iff-τ-tilting-finite contract — and the **LIVE wall-and-chamber picture
  drawn no-code in the browser for n = 2, 3** — the C4 flagship.
- **The lattice theory of torsion classes (Demonet–Iyama–Reading–Reiten–Thomas).**
  The finite lattice `tors A` as an abstract lattice, the congruence lattice
  `Con(tors A)`, the forcing order on bricks, canonical join representations, and the
  **wide-subcategory poset** (Enomoto's core label order = κ order) — one click via the
  `congruences` compute kind, certified complete iff `A` is τ-tilting-finite. kA₂ =
  the pentagon N₅ / M₃; kA₃ = the 14-element `Con` / NC(A₃) wide poset.
- **The τ-cluster morphism category `W(A)` (Buan–Marsh; Hanson–Igusa, P66).** Its
  objects (= the wide subcategories), its rank-graded morphisms, the **cube-complex
  classifying space** with the `K(π,1)` verdict for Nakayama / hereditary-Dynkin algebras,
  and the **picture-group presentation** (generators = bricks, relations per rank-2 wide,
  abelianization by exact SNF) — one click via `tau_cluster`, certified complete iff
  τ-tilting-finite. kA₂ = 3 generators + 1 pentagon relation, face vector `(5,11,5)`; kA₃ =
  6 generators, 4 atom + 2 commutation, `(14,49,49,14)` — distinct from kZ₃/rad²'s
  `(14,48,48,14)` on the same coarse counts.
- **Wall-and-chamber structure via bricks (Brüstle–Smith–Treffinger, P63).** The wall
  `D(B)` of every brick as an **exact rational inequality system** over the submodule
  dim-vectors (`D(B) = {θ : θ·dim B = 0 and θ·dim N ≤ 0 for every N ⊆ B}`), the chambers
  as g-vector cones, walls grouped one-per-brick, certified complete **iff
  τ-tilting-finite** (else an honest bounded region) — with a **LIVE 2D/3D fan drawing
  for rank ≤ 3** that overlays each labeled brick-wall, clickable no-code via
  `wall_chamber`.
- **Silting theory (Aihara–Iyama, P67).** A silting-object verifier in `K^b(proj A)`
  (presilting `Hom_{D^b}(T,T[n>0]) = 0` on the exact positive window + honest
  three-valued generation — certified on the tilting / 2-term / local classes, `"unknown"`
  where K₀ alone cannot decide), single silting mutation `μ_X^±` via one approximation
  triangle (the mutant re-verifies silting, `μ^-∘μ^+ = id`), a bounded-radius exploration
  with loud truncation (the silting quiver can be infinite — no general BFS; complete only
  for local), and the co-t-structure dictionary — cross-checked against P45's τ-tilting
  (2-term slice) and Oppermann's `End(μT)` quiver rule, no-code in the browser.
- **Exceptional sequences (R27+R28).** The classical hereditary theory — an
  orthogonality recognizer, **braid mutation** `σ_i` (universal-extension / kernel /
  cokernel constructions), the Crawley-Boevey / Ringel **braid-orbit transitivity**
  certificate, and the Dynkin closed-form counts `#CES = n!·hⁿ/|W|` (`A_n = (n+1)^{n-1}`,
  `D_4 = 162`) — and **Buan–Marsh τ-exceptional sequences** via the **Jasso
  τ-perpendicular reduction** and the ordered-support-τ-tilt bijection
  `#signed = n!·#sτt` (materialised + cross-checked). Hereditary-only / Dynkin-only for
  the classical side, τ-tilting-finite-only for the τ side, loud otherwise. Clickable via
  `exceptional_sequences`.
- **Split-extension LES + certified arrow removal (R5+R6, P72).** The
  Cibils–Marcos–Redondo–Solotar **trivial-extension Hochschild long exact sequence** —
  `HH^•(T(B))` assembled from the flanks `HH^•(L,D(B))` / `HH^•(L,B)` and the snake
  connecting map, cross-checked against the direct answer, with the grading-derivation
  witness `HH^1(T(B)) ≠ 0` (and `= k ⊕ HH^1(B)` on directed `B`); and the
  Cibils–Lanzilotta–Marcos–Solotar **certified arrow removal** — deleting inert arrows
  (in no relation) gives a clean `HH_n(A) ≅ HH_n(B)` for `n ≥ 2`, with the honest
  cohomology Ext-correction. Clickable via `split_extension` / `arrow_removal`.
- **Left/right parts of the module category (Assem–Coelho–Trepode, P55).** The
  left/right parts `L_A`, `R_A` via the closed-under-predecessors pd/id ≤ 1 sweep on
  the knitted AR quiver, the finite complement `ind A ∖ (L_A ∪ R_A)` (the laura datum —
  non-empty even for ada), the Ext-injectives of `add L_A` (and dual Ext-projectives of
  `add R_A`), and the left/right support algebras `A_λ`, `A_ρ` (products of tilted
  algebras) as presented induced-convex-subquiver algebras — the recognizer-ladder
  substrate, no-code in the browser (representation-finite scope, loud otherwise).
- **Algebra families and citations.** A curated catalog of named families
  (`NakayamaAlgebra`, `QuantumCI`, `ExteriorAlgebra`, `IncidenceAlgebra`,
  `PreprojectiveAlgebra`, `TrivialExtension`, `TensorProduct`, …) with `families()`
  discovery and the `zoo` iterator, each stamped with the literature it comes from;
  `A.citations()` and `bibliography(...)` resolve those keys to grouped, annotated
  references, plus a batch scan surface for family sweeps.
- **Zero-code GUI** — the containerized app serves the full-engine GUI offline
  on localhost (`quiverlab-hpc gui`), with your machine's real cores and RAM.

Everything is exact — no floating point, ever — and the full test suite runs
green on both the numba kernel path and the pure-Python path
(`QUIVERLAB_NO_NUMBA=1`).

Honest scope note: the calculus is now public as **structure-constant tables** over
the whole HH basis (`A.cup_products(top)` and friends). A classy `A.cup(u, v)` on
two *named* cohomology-class representatives still awaits the cohomology-classes
machinery of a later phase (see `docs/plans/ROADMAP.md`); and the Gerstenhaber
bracket is GF(p)-only and window-bounded.

Coming next (see `docs/plans/ROADMAP.md`): full operation transport, drawing and
TikZ export, worked-steps PDFs, and an optional QPA backend.

## Draw it, and read the worked steps

```python
from quiverlab import Quiver, CC

Q = Quiver(vertices=[1, 2, 3, 4],
           arrows={"a": (1, 2), "b": (2, 4), "c": (1, 3), "d": (3, 4)})
A = Q.algebra(relations=["a*b - c*d"], field=CC)

A.draw(file="square.svg")     # matplotlib PNG/SVG: loops, parallels, relations below
print(A.tikz())               # same layout, paste-into-paper TikZ

A.hochschild_cohomology(2)    # writes quiverlab_traces/HHc_<hash>.pdf (or .html) and
                              # prints: Worked steps: quiverlab_traces/HHc_3f2a.pdf (N pp)
```

Worked-steps documents are on by default (`quiverlab.verbose = True`); every claim
in them is a golden-file-tested equality with the value the engine computed. Turn
them off per call (`A.hochschild_cohomology(2, verbose=False)`) or globally
(`quiverlab.verbose = False`). Reports are delivered as a self-contained,
JavaScript-free HTML document (math shown as TeX source) plus an exact JSON event
stream; the browser's Print-to-PDF turns the HTML into a page-ready document when
one is needed.

## Web interface

A no-code web GUI (`webapp/`) exposes the library for algebraists who prefer not
to write Python: pick a family, a field, and invariants; read exact results with
rendered mathematics; download the worked-steps PDF. Small computations run
instantly; deep ones become queued jobs with a permalink; very large ones run as
email-verified **big jobs** (a single-use magic link; requires an outbound SMTP
relay, disabled otherwise). Every result carries a References block (the
literature the computation stands on, from the library's citations subsystem),
and `/literature` shows the full curated bibliography. The UI is bilingual
(English at `/`, Spanish at `/es/`) with a public feedback form at `/feedback`
(including a "suggest literature" category).

Results are cached: because every computation is exact and deterministic, a
previously computed example is never recomputed — an identical request is served
instantly from the cache, across users. Email verification gates only the *cost* of
computing a new big example, not access to the mathematics, so a big example that
someone already computed is served immediately, with no email needed.

Each finished computation exposes downloadable artifacts under
`/download/<job-id>/…`: `result.json` (exact dimensions, references, and a
copy-paste reproduction snippet), the worked-steps `trace.pdf` (or a
self-contained `trace_steps.html` when no LaTeX toolchain is present), and
`tikz.tex` when a drawing was requested. Every number is exact — the server never
approximates, and an out-of-scope request fails loudly rather than silently
truncating.

Run it locally:

```bash
pip install -e ".[web,fast]"
uvicorn webapp.server.app:create_app --factory --reload      # terminal 1
python -m webapp.worker.run_loop                             # terminal 2
# open http://127.0.0.1:8000
```

The web tier is two processes sharing one SQLite database: the FastAPI app
(instant computations under a hard wall-time net; everything larger is enqueued)
and one or more worker loops (each job runs in a resource-capped subprocess). A
full-stack local smoke driving the real processes over HTTP lives at
[`scripts/webapp_smoke.py`](scripts/webapp_smoke.py); the equivalent flow runs
in-process (no ports) as `tests/webapp/test_acceptance.py`.

Deploy (DRAC Arbutus, Docker Compose + Caddy TLS): see
[`webapp/deploy/PROVISIONING.md`](webapp/deploy/PROVISIONING.md).

## HPC and offline use (container)

The same library ships as **one container** (`ghcr.io/marcoarmenta/quiverlab`) with
a `quiverlab-hpc` CLI, serving two stories from the one image.

**Run a big example on a SLURM cluster in 5 steps** (only `ssh`/`scp`/`sbatch`
needed; Apptainer is rootless):

```bash
apptainer pull quiverlab.sif docker://ghcr.io/marcoarmenta/quiverlab:latest   # 1. pull
apptainer run quiverlab.sif sample-config > my-config.yaml                    # 2. config (or export from the GUI)
sbatch slurm/quiverlab-drac.sbatch my-config.yaml result.json                 # 3. submit
scp you@cluster:result.json .                                                 # 4. fetch
apptainer run --bind "$PWD" quiverlab.sif render result.json -o report.html   # 5. render locally (HTML/JSON)
```

Very large examples become reachable via **atomic per-degree checkpoints**: a job
that runs out of wall time exits 75, requeues, and resumes from `$SCRATCH` on the
next submit — just `sbatch` again. **quiverlab is CPU-only** — request cores
(`--cpus-per-task`) and RAM (`--mem`), never a GPU; the arithmetic is exact
(integers mod p / rationals) and a GPU would sit idle. `quiverlab-hpc estimate
my-config.yaml` suggests the resources.

**Offline laptop app.** Pull the image once with internet, then run
`apptainer run quiverlab.sif gui` (or `docker run -p 8000:8000 … gui`) and open
`http://localhost:8000` — the zero-code GUI computes locally with no network, showing
your machine's detected cores/RAM, memory/time estimates, and the limits you are
computing under, and ships precomputed examples.

Full instructions: [Run on your HPC cluster](docs/hpc.md) and
[Offline laptop app](docs/offline-app.md).


## Writing and running config files (the containerized app)

Everything the container computes is driven by **one YAML document** — the same
schema the webapp and the browser GUI speak, so a config exported from the GUI
runs unchanged on a cluster. Run it with any of the three installs:

```bash
# Docker (make the output dir writable for the in-image uid first)
mkdir -p out && chmod 777 out
docker run --rm -v "$PWD:/cfg:ro" -v "$PWD/out:/out" quiverlab:local \
    run /cfg/my-config.yaml -o /out/result.json
docker run --rm -v "$PWD/out:/out" quiverlab:local \
    render /out/result.json -o /out/report.html --format html

# Apptainer (clusters; rootless)
apptainer run --bind "$PWD" quiverlab.sif run my-config.yaml -o result.json
apptainer run --bind "$PWD" quiverlab.sif render result.json -o report.html

# Plain pip install (no container)
pip install "quiverlab[fast,hpc]"
quiverlab-hpc run my-config.yaml -o result.json
quiverlab-hpc render result.json -o report.html
```

`quiverlab-hpc sample-config` prints an annotated template and
`quiverlab-hpc estimate my-config.yaml` suggests `--time/--cpus-per-task/--mem`
before you submit. The rendered report shows the quiver presentation (labeled
arrows), every requested invariant with rendered matrices, and a resources
footer (wall time, peak RSS, cores).

### Anatomy of a config

```yaml
schema: 2                  # 1 = algebra-only; 2 required for module blocks
algebra:                   # EITHER a named family ...
  kind: family
  family: QuantumCI        # discover names: python -c "import quiverlab; print(quiverlab.families())"
  params: {q: 2, a: 2, b: 2}
  field: {kind: GF, p: 32003, n: 1}    # GF(p^n), or {kind: CC} for exact char 0
compute:                   # any subset; ranged kinds take "kind:lo..hi"
  - "hh_cohomology:0..8"
  - cartan
artifacts: {tikz: true}    # optional; tikz.tex written beside result.json
hpc:                       # optional; CLI-only budgets
  time_limit_s: 3600
  max_mem_bytes: 4294967296
```

**Compute kinds.** Algebra-level: `hh_cohomology:lo..hi`, `hh_homology:lo..hi`,
`cartan`, `coxeter_polynomial`, `global_dimension`, `center`, `dimension`.
Module-level (need a `module` block, schema 2): `dimension_vector`,
`rad_top_soc`, `decompose`, `tau`, `tau_minus`, `projective_resolution:0..n`,
`injective_resolution:0..n`, `projective_dimension`, `injective_dimension`,
`ext:0..n` (needs `ext_target`), `tor:0..n` (needs `tor_target`, a **left**
module).

**Module blocks.** A module is either a builtin pick
(`module: {builtin: {kind: simple|projective|injective, vertex: 3, side: right}}`)
or an explicit representation: `dims` maps **string** vertex labels to
dimensions (missing vertices are 0), `maps` gives one `dim_target x dim_source`
matrix per arrow (arrows touching a 0-dimensional vertex may be omitted).
Entries are exact data — integers or fraction strings like `"1/2"`; floats are
refused loudly. `side: left` means a representation of the opposite quiver.

### Worked configs

A hereditary path algebra over **exact characteristic 0** — no proxy prime:

```yaml
schema: 1
algebra:
  kind: family
  family: PathAlgebra
  params: {type_or_quiver: "A5"}
  field: {kind: CC}
compute: [cartan, coxeter_polynomial, global_dimension, dimension]
# dim 15, gl.dim = 1 (exact), the A5 Coxeter polynomial
```

The exterior algebra in char 0 — Hochschild cohomology grows linearly:

```yaml
schema: 1
algebra:
  kind: family
  family: ExteriorAlgebra
  params: {n: 2}
  field: {kind: CC}
compute: ["hh_cohomology:0..4", center, dimension]
# HH^0..4 = [2, 4, 6, 8, 10]
```

A truncated path algebra over the **non-prime field GF(9)**:

```yaml
schema: 1
algebra:
  kind: family
  family: TruncatedPathAlgebra
  params: {type_or_quiver: "A6", r: 3}
  field: {kind: GF, p: 3, n: 2}
compute: [cartan, global_dimension, "hh_cohomology:0..4"]
# gl.dim = 3 (exact)
```

An **explicit quiver** (the Kronecker quiver, no relations) with a no-code
module given by matrices — the regular representation `R_2` (`a` acts by 1,
`b` by 2):

```yaml
schema: 2
algebra:
  kind: quiver
  vertices: [1, 2]
  arrows: {a: [1, 2], b: [1, 2]}
  relations: []
  field: {kind: GF, p: 5, n: 1}
compute: [dimension, cartan, global_dimension, dimension_vector,
          rad_top_soc, decompose, tau, "projective_resolution:0..3"]
module:
  side: right
  dims: {"1": 1, "2": 1}
  maps:
    a: [[1]]
    b: [[2]]
```

An explicit quiver with a **non-monomial relation** — the commutative square,
over CC:

```yaml
schema: 1
algebra:
  kind: quiver
  vertices: [1, 2, 3, 4]
  arrows: {a: [1, 2], b: [1, 3], c: [2, 4], d: [3, 4]}
  relations: ["a*c - b*d"]
  field: {kind: CC}
compute: [dimension, global_dimension, center, "hh_cohomology:0..3"]
# dim 9, gl.dim = 2 (exact)
```

Larger ready-to-run configs live in
[`container/examples/`](container/examples/): the quantum complete intersection
with the full invariant surface ([`qci-q2.yaml`](container/examples/qci-q2.yaml)),
a cyclic Nakayama algebra with a decomposable module
([`nakayama-kz4.yaml`](container/examples/nakayama-kz4.yaml)), the 3x3
commutative grid with interior modules paired by the Auslander-Reiten
translate — `Ext^1(M, tau M) = 1` ([`grid3x3.yaml`](container/examples/grid3x3.yaml)),
and a dim-220 deep-degree run ([`nakayama-kz20-deep.yaml`](container/examples/nakayama-kz20-deep.yaml)).
Every one computes byte-identically in the container and from the wheel.

## Install the Python library

```bash
pip install quiverlab                 # pure-Python core, no external systems
pip install "quiverlab[fast]"         # + numba GF(p) acceleration (optional)
pip install "quiverlab[qpa]"          # + GAP/QPA cross-check backend (macOS/Linux)
pip install "quiverlab[fast,hpc]"     # + the quiverlab-hpc CLI (configs, reports)
```

MIT © 2026 Marco Armenta
