algebra

quiverlab.core.algebra

The structure-constant Algebra: quiverlab's internal currency (spec §5). T[i][j] is the coordinate vector of b_i * b_j. 'Unit-adapted' means b_0 = 1_A (hanlab's convention), which the bar complex requires.

Algebra

Algebra(domain, T, unit, basis_labels=None, is_unit_adapted=None, _quiver=None, _relations=None, _family_citations=())

Source code in src/quiverlab/core/algebra.py

def __init__(self, domain, T, unit, basis_labels=None, is_unit_adapted=None, _quiver=None,
             _relations=None, _family_citations=()):
    self.domain = domain
    self.T = T
    self.unit = unit
    self.dim = len(T)
    self.basis_labels = basis_labels
    self.quiver = _quiver
    self.relations = _relations
    self._family_citations = tuple(_family_citations)
    if is_unit_adapted is None:
        one = domain.one()
        is_unit_adapted = (
            not domain.is_zero(unit[0])
            and domain.eq(unit[0], one)
            and all(domain.is_zero(c) for c in unit[1:])
        )
    self.is_unit_adapted = is_unit_adapted

ar_invariants

ar_invariants(budget_modules=256, budget_dim=4096)

The Auslander-Reiten component invariants (Plan 57 / R21): Liu left/right degrees of irreducible maps, sectional paths, the postprojective/preinjective/regular partition, directing modules, the representation-directed recognizer (Gamma_A acyclic) and the generalized-standard flag. Returns an :class:~quiverlab.modules.ar_invariants.ARInvariants; certified iff the knit closes (rep-finite), else an honest off-scope refusal.

Source code in src/quiverlab/core/algebra.py

def ar_invariants(self, budget_modules=256, budget_dim=4096):
    """The Auslander-Reiten component invariants (Plan 57 / R21): Liu left/right
    degrees of irreducible maps, sectional paths, the
    postprojective/preinjective/regular partition, directing modules, the
    representation-directed recognizer (``Gamma_A`` acyclic) and the
    generalized-standard flag. Returns an
    :class:`~quiverlab.modules.ar_invariants.ARInvariants`; certified iff the knit
    closes (rep-finite), else an honest off-scope refusal."""
    from quiverlab.modules.ar_invariants import ar_invariants
    return ar_invariants(self, budget_modules=budget_modules,
                         budget_dim=budget_dim)

ar_quiver

ar_quiver(budget_modules=256, budget_dim=4096)

The Auslander-Reiten quiver, knitted from the projectives via almost-split sequences (Plan 41 / C3). Returns an ARQuiver; complete iff rep-finite, else a LOUD budget cap (.is_complete, .status).

Source code in src/quiverlab/core/algebra.py

def ar_quiver(self, budget_modules=256, budget_dim=4096):
    """The Auslander-Reiten quiver, knitted from the projectives via almost-split
    sequences (Plan 41 / C3). Returns an ``ARQuiver``; complete iff rep-finite,
    else a LOUD budget cap (``.is_complete``, ``.status``)."""
    from quiverlab.modules.ar import knit_ar_quiver
    return knit_ar_quiver(self, budget_modules=budget_modules,
                          budget_dim=budget_dim)

arrow_removal

arrow_removal(arrows=None, top=6, *, side='both')

The certified arrow-removal HH reduction (CLMS 1812.07655, Plan 72 / R6): build B = A ∖ (inert arrows) and report the clean HH_{≥2} homology isomorphism (Thm 3.2) + the cohomology Ext-correction (Thm 4.2). arrows=None removes ALL inert arrows. Returns an ArrowRemovalReport.

Source code in src/quiverlab/core/algebra.py

def arrow_removal(self, arrows=None, top=6, *, side="both"):
    """The certified arrow-removal HH reduction (CLMS ``1812.07655``, Plan 72 /
    R6): build ``B = A ∖ (inert arrows)`` and report the clean ``HH_{≥2}``
    homology isomorphism (Thm 3.2) + the cohomology Ext-correction (Thm 4.2).
    ``arrows=None`` removes ALL inert arrows. Returns an ``ArrowRemovalReport``."""
    from quiverlab.hochschild.arrow_removal import arrow_removal
    return arrow_removal(self, arrows=arrows, top=top, side=side)

barcode

barcode(M, *, budget=512, budget_modules=256)

The barcode / generalized persistence diagram of a persistence module M (Plan 69 / R33). A_n/zigzag: the interval decomposition (Gabriel / Botnan-Crawley-Boevey), field-robust over any exact domain. CL(n<=4): the AR-quiver-indexed generalized persistence diagram (Escolar-Hiraoka), char-scoped. Returns a :class:~quiverlab.modules.barcode.Barcode; refuses loudly on a non-A_n/non-CL quiver, CL(n>=5), or a char-undecidable input.

Source code in src/quiverlab/core/algebra.py

def barcode(self, M, *, budget=512, budget_modules=256):
    """The barcode / generalized persistence diagram of a persistence module ``M``
    (Plan 69 / R33). ``A_n``/zigzag: the interval decomposition (Gabriel /
    Botnan-Crawley-Boevey), field-robust over any exact domain. ``CL(n<=4)``: the
    AR-quiver-indexed generalized persistence diagram (Escolar-Hiraoka), char-scoped.
    Returns a :class:`~quiverlab.modules.barcode.Barcode`; refuses loudly on a
    non-A_n/non-CL quiver, ``CL(n>=5)``, or a char-undecidable input."""
    from quiverlab.modules.barcode import barcode
    return barcode(M, budget=budget, budget_modules=budget_modules)

basic_algebra

basic_algebra()

The basic algebra eAe (one primitive idempotent per iso class), Morita-equivalent to this algebra, as a structure-constant Algebra (Plan 44).

Source code in src/quiverlab/core/algebra.py

def basic_algebra(self):
    """The basic algebra ``eAe`` (one primitive idempotent per iso class),
    Morita-equivalent to this algebra, as a structure-constant Algebra (Plan 44)."""
    from quiverlab.core.basic import basic_algebra
    return basic_algebra(self)

bongartz_completion

bongartz_completion(T)

The Bongartz complement middle term E of a partial tilting module T (pd<=1, Ext^1(T,T)=0): is_tilting_module(direct_sum(T, E)) is True (Plan 44).

Source code in src/quiverlab/core/algebra.py

def bongartz_completion(self, T):
    """The Bongartz complement middle term ``E`` of a partial tilting module ``T``
    (pd<=1, Ext^1(T,T)=0): ``is_tilting_module(direct_sum(T, E))`` is True (Plan 44)."""
    from quiverlab.modules.tilting import bongartz_completion
    return bongartz_completion(T)

bounded_extension

bounded_extension(new_arrows, *, side='auto', nilp_cap=8, pd_cap=16)

Decide whether B subset A (removing new_arrows) is a bounded extension (CLMS 2101.02597 Def. 2.3, Plan 73 / R7): A/B tensor nilpotent + finite pd_{B^e} + one-sided B-projective. Returns a BoundedCertificate (honest None when a leg is undecided).

Source code in src/quiverlab/core/algebra.py

def bounded_extension(self, new_arrows, *, side="auto", nilp_cap=8, pd_cap=16):
    """Decide whether ``B subset A`` (removing ``new_arrows``) is a **bounded**
    extension (CLMS ``2101.02597`` Def. 2.3, Plan 73 / R7): ``A/B`` tensor
    nilpotent + finite ``pd_{B^e}`` + one-sided ``B``-projective. Returns a
    ``BoundedCertificate`` (honest ``None`` when a leg is undecided)."""
    from quiverlab.invariants.han import bounded_extension
    return bounded_extension(self, new_arrows, side=side, nilp_cap=nilp_cap,
                             pd_cap=pd_cap)

bv_operator

bv_operator(top, engine='auto', max_cells=4000000)

The Batalin-Vilkovisky operator Delta: HH^n -> HH^{n-1} for 1 <= n <= top, on the recorded HH basis, exact (Plan 54).

Delta is Connes' B carried across the sigma-twisted Frobenius duality HH^n(A) ~= D(HH_n(A, {}_1A_nu)); its defect from being a cup-derivation is the Gerstenhaber bracket (the BV relation). Requires a Frobenius algebra whose Nakayama automorphism is semisimple (symmetric algebras included as the nu-inner Tradler anchor); a loud typed refusal otherwise (non-Frobenius, or Frobenius with a non-semisimple nu -- the general Bian-Itagaki-Kou-Lyu- Zhou construction is out of v1 scope). Returns a BVOperator whose .blocks() serializes identically for every serving tier.

engine: 'auto' (the GF(p) bar/tt route in v1); 'bar' is the explicit GF(p) route (loud off GF(p)); 'cs' is reserved for the P51 past-window / off-GF(p) enhancer (loud 'not available until P51' -- never a silent fallback). v1 is GF(p) and in-window (the bracket arbiter that certifies correctness is GF(p)-window-bounded); off GF(p) or past window refuses loudly.

Source code in src/quiverlab/core/algebra.py

def bv_operator(self, top, engine="auto", max_cells=4_000_000):
    """The Batalin-Vilkovisky operator Delta: HH^n -> HH^{n-1} for
    1 <= n <= top, on the recorded HH basis, exact (Plan 54).

    Delta is Connes' B carried across the sigma-twisted Frobenius duality
    HH^n(A) ~= D(HH_n(A, {}_1A_nu)); its defect from being a cup-derivation is
    the Gerstenhaber bracket (the BV relation). Requires a Frobenius algebra
    whose Nakayama automorphism is semisimple (symmetric algebras included as
    the nu-inner Tradler anchor); a loud typed refusal otherwise (non-Frobenius,
    or Frobenius with a non-semisimple nu -- the general Bian-Itagaki-Kou-Lyu-
    Zhou construction is out of v1 scope). Returns a ``BVOperator`` whose
    ``.blocks()`` serializes identically for every serving tier.

    engine: 'auto' (the GF(p) bar/tt route in v1); 'bar' is the explicit GF(p)
    route (loud off GF(p)); 'cs' is reserved for the P51 past-window / off-GF(p)
    enhancer (loud 'not available until P51' -- never a silent fallback). v1 is
    GF(p) and in-window (the bracket arbiter that certifies correctness is
    GF(p)-window-bounded); off GF(p) or past window refuses loudly."""
    from quiverlab.fields.primefield import PrimeField
    from quiverlab.hochschild.bv.hypothesis import classify_bv
    from quiverlab.hochschild.bv.transport import (
        bv_matrices_semisimple, bv_matrices_symmetric)
    if engine not in ("auto", "bar", "cs"):
        raise QuiverlabError(
            f"unknown engine {engine!r} for the BV operator",
            hint="choose 'auto', 'bar', or 'cs'")
    if engine == "cs":
        raise QuiverlabError(
            "engine='cs' BV operator (native past-window / off-GF(p)) is not "
            "available until P51 lands -- no silent fallback",
            hint="use engine='auto' over GF(p) in the bar window")
    if not isinstance(self.domain, PrimeField):
        raise QuiverlabError(
            "BV operator v1 is GF(p) only (the bracket arbiter that certifies "
            f"it is GF(p)-window-bounded); this algebra is over {self.domain.name}",
            hint="compute over GF(p), or wait for the P51 CS enhancer")
    h = classify_bv(self)
    if not h.applies:
        raise QuiverlabError(h.refusal)
    if h.route == "symmetric":
        return bv_matrices_symmetric(self, top, max_cells=max_cells)
    return bv_matrices_semisimple(self, top, max_cells=max_cells)

canonical_decomposition

canonical_decomposition(d, *, budget=4096)

The Kac canonical decomposition of the dimension vector d over a HEREDITARY DYNKIN algebra: d = sum m_i * beta_i into positive roots whose generic module is rigid (Plan 49 / C8). Loud off scope (Euclidean/wild deferred, non-hereditary refused).

Source code in src/quiverlab/core/algebra.py

def canonical_decomposition(self, d, *, budget=4096):
    """The Kac canonical decomposition of the dimension vector d over a
    HEREDITARY DYNKIN algebra: d = sum m_i * beta_i into positive roots whose
    generic module is rigid (Plan 49 / C8). Loud off scope (Euclidean/wild
    deferred, non-hereditary refused)."""
    from quiverlab.invariants.geometry import canonical_decomposition
    return canonical_decomposition(self, d, budget=budget)

cap_products

cap_products(top, engine='auto', max_cells=4000000)

Structure-constant tables of the cap action HH^p (x) HH_n -> HH_{n-p} for p <= n <= top. Same engine semantics as cup_products.

Source code in src/quiverlab/core/algebra.py

def cap_products(self, top, engine="auto", max_cells=4_000_000):
    """Structure-constant tables of the cap action HH^p (x) HH_n ->
    HH_{n-p} for p <= n <= top. Same engine semantics as cup_products."""
    return self._product_dispatch("cap", top, engine, max_cells)

cartan_matrix

cartan_matrix()

Integer Cartan matrix from the quiver presentation (any field).

Source code in src/quiverlab/core/algebra.py

def cartan_matrix(self):
    """Integer Cartan matrix from the quiver presentation (any field)."""
    from quiverlab.invariants.cartan import cartan_matrix
    return cartan_matrix(self)

center

center()

(dim, basis) of the center Z(A), exact over any field (spec §3.5).

Source code in src/quiverlab/core/algebra.py

def center(self):
    """(dim, basis) of the center Z(A), exact over any field (spec §3.5)."""
    from quiverlab.invariants.scalar import center
    return center(self)

chain_complex

chain_complex(terms, dmats, check=True)

A bounded chain complex of A-modules (Plan 39): terms is {degree: Module} and dmats is {n: d_n} with d_n: terms[n] -> terms[n-1] (rows=target, the homological convention). Returns a :class:~quiverlab.modules.complexes.ChainComplex; homology, shift/truncate, mapping cones and hyper-Ext follow from it (validated d.d = 0 at construction unless check=False).

Source code in src/quiverlab/core/algebra.py

def chain_complex(self, terms, dmats, check=True):
    """A bounded chain complex of A-modules (Plan 39): ``terms`` is
    ``{degree: Module}`` and ``dmats`` is ``{n: d_n}`` with
    ``d_n: terms[n] -> terms[n-1]`` (rows=target, the homological convention).
    Returns a :class:`~quiverlab.modules.complexes.ChainComplex`; homology,
    shift/truncate, mapping cones and hyper-Ext follow from it (validated
    ``d.d = 0`` at construction unless ``check=False``)."""
    from quiverlab.modules.complexes import ChainComplex
    return ChainComplex(terms, dmats, check=check)

change_of_basis

change_of_basis(P)

New algebra in the basis whose j-th vector has old coordinates column j of P.

Source code in src/quiverlab/core/algebra.py

def change_of_basis(self, P):
    """New algebra in the basis whose j-th vector has old coordinates column j of P."""
    dom = self.domain
    m = self.dim
    if rank(P, dom) != self.dim:
        raise QuiverlabError("change of basis matrix is singular",
                             hint="columns must form a basis")
    cols = [[P[i][j] for i in range(m)] for j in range(m)]
    newT = []
    for i in range(m):
        row = []
        for j in range(m):
            prod_old = self.multiply(cols[i], cols[j])
            x = solve(P, prod_old, dom)
            if x is None:
                raise QuiverlabError("change of basis matrix is singular",
                                     hint="columns must form a basis")
            row.append(x)
        newT.append(row)
    new_unit = solve(P, list(self.unit), dom)
    if new_unit is None:
        raise QuiverlabError("change of basis matrix is singular",
                             hint="columns must form a basis")
    return Algebra(dom, newT, new_unit, basis_labels=None,
                   _quiver=self.quiver, _relations=self.relations)

characteristic_tilting

characteristic_tilting(order=None)

The characteristic tilting module T = (+) T(i) (Ringel, self-certified). The tilting summand count inherits the char 0 / char > dim caveat (Plan 47).

Source code in src/quiverlab/core/algebra.py

def characteristic_tilting(self, order=None):
    """The characteristic tilting module ``T = (+) T(i)`` (Ringel, self-certified). The
    tilting summand count inherits the char 0 / char > dim caveat (Plan 47)."""
    from quiverlab.modules.quasihereditary import characteristic_tilting
    return characteristic_tilting(self, order)

citations

citations()

Registry keys relevant to this algebra: its family stamp plus the HH engine (spec §3.9). Every key resolves via quiverlab.citations.

Source code in src/quiverlab/core/algebra.py

def citations(self):
    """Registry keys relevant to this algebra: its family stamp plus the HH engine
    (spec §3.9). Every key resolves via quiverlab.citations."""
    seen, out = set(), []
    for k in tuple(getattr(self, "_family_citations", ())) + self._engine_citations():
        if k not in seen:
            seen.add(k)
            out.append(k)
    return tuple(out)

cluster_category

cluster_category()

The Amiot-Keller cluster category C_A = D^b(mod A)/tau^-1[1] of this algebra (Plan 79), as a certified finite model: the fundamental domain ind(mod A) |_| {P_v[1]}, the cluster-tilting objects (= support tau-tilting pairs, AIR), the cluster-tilted End-algebra, and the 2-Calabi-Yau certificate. HEREDITARY and ACYCLIC only -- refuses loudly otherwise.

Source code in src/quiverlab/core/algebra.py

def cluster_category(self):
    """The Amiot-Keller cluster category ``C_A = D^b(mod A)/tau^-1[1]`` of this
    algebra (Plan 79), as a certified finite model: the fundamental domain
    ``ind(mod A) |_| {P_v[1]}``, the cluster-tilting objects (= support tau-tilting
    pairs, AIR), the cluster-tilted End-algebra, and the 2-Calabi-Yau certificate.
    HEREDITARY and ACYCLIC only -- refuses loudly otherwise."""
    from quiverlab.cluster import ClusterCategory
    return ClusterCategory(self)

complexity

complexity(n)

Apparent complexity from the minimal A^e resolution's growth (GF(p) only).

Exact for path-basis algebras of any vertex count (Plan 13: the engine builds the corner-typed minimal projective resolution). Remaining caveat: a memory-truncated build adds a silent prefix (read the number as a lower bound in that case). See invariants.scalar.complexity.

Source code in src/quiverlab/core/algebra.py

def complexity(self, n):
    """Apparent complexity from the minimal A^e resolution's growth (GF(p) only).

    Exact for path-basis algebras of any vertex count (Plan 13: the engine builds
    the corner-typed minimal projective resolution). Remaining caveat: a
    memory-truncated build adds a silent prefix (read the number as a lower bound
    in that case). See ``invariants.scalar.complexity``.
    """
    from quiverlab.invariants.scalar import complexity
    return complexity(self, n)

congruence_lattice

congruence_lattice(budget=512)

Con(tors A) (Plan 64 / R26, DIRRT): the congruence lattice via principal cover-congruences, its join-irreducible congruences (= the bricks), the forcing order on bricks, and |Con(tors A)|. Distributive by Funayama-Nakayama. Certified complete iff A is tau-tilting-finite.

Source code in src/quiverlab/core/algebra.py

def congruence_lattice(self, budget=512):
    """``Con(tors A)`` (Plan 64 / R26, DIRRT): the congruence lattice via principal
    cover-congruences, its join-irreducible congruences (= the bricks), the forcing order
    on bricks, and ``|Con(tors A)|``. Distributive by Funayama-Nakayama. Certified
    complete iff ``A`` is tau-tilting-finite."""
    from quiverlab.tautilting.congruence import congruence_lattice
    return congruence_lattice(self, budget=budget)

connes_differentials

connes_differentials(top, max_cells=4000000)

Induced Connes differentials B : HH_n -> HH_{n+1} (matrices + ranks) for 0 <= n < top. GF(p) via the engine (b,B); any other exact Domain via the generic mixed complex — no engine choice to make.

Source code in src/quiverlab/core/algebra.py

def connes_differentials(self, top, max_cells=4_000_000):
    """Induced Connes differentials B : HH_n -> HH_{n+1} (matrices +
    ranks) for 0 <= n < top. GF(p) via the engine (b,B); any other exact
    Domain via the generic mixed complex — no engine choice to make."""
    from quiverlab.hochschild.products import connes_b_tables
    return connes_b_tables(self, top, max_cells=max_cells)

corner_algebra

corner_algebra(vertices)

The corner algebra eAe (NOT the subquiver algebra) at vertices (Plan 47).

Source code in src/quiverlab/core/algebra.py

def corner_algebra(self, vertices):
    """The corner algebra ``eAe`` (NOT the subquiver algebra) at ``vertices`` (Plan 47)."""
    from quiverlab.modules.recollement import Recollement
    return Recollement(self, vertices).eAe

costandard_modules

costandard_modules(order=None)

The costandard modules Nabla(i) = D(Delta_{A^op}(i)) (Plan 47).

Source code in src/quiverlab/core/algebra.py

def costandard_modules(self, order=None):
    """The costandard modules ``Nabla(i) = D(Delta_{A^op}(i))`` (Plan 47)."""
    from quiverlab.modules.quasihereditary import costandard_modules
    return costandard_modules(self, order)

coxeter_matrix

coxeter_matrix()

Coxeter matrix -C^{-T} C (exact; loud if the Cartan matrix is singular).

Source code in src/quiverlab/core/algebra.py

def coxeter_matrix(self):
    """Coxeter matrix -C^{-T} C (exact; loud if the Cartan matrix is singular)."""
    from quiverlab.invariants.cartan import coxeter_matrix
    return coxeter_matrix(self)

coxeter_polynomial

coxeter_polynomial()

Characteristic polynomial of the Coxeter matrix, as an exact sympy Poly.

Source code in src/quiverlab/core/algebra.py

def coxeter_polynomial(self):
    """Characteristic polynomial of the Coxeter matrix, as an exact sympy Poly."""
    from quiverlab.invariants.cartan import coxeter_polynomial
    return coxeter_polynomial(self)

coxeter_spectral

coxeter_spectral()

Certified Coxeter spectral report (Plan 58 / R20): exact ZZ[x] cyclotomic factorization with Phi_n labels, cyclotomic / quasi-unipotent verdict, finite Coxeter order (Phi^m = I) or None with an honest reason, exact outside-unit- circle root count, and the spectral radius / Mahler measure as CERTIFIED ALGEBRAIC NUMBERS (minimal polynomial + rational isolating interval) -- never a float. Any field that refuses on this input is captured per-field, never a crash.

Source code in src/quiverlab/core/algebra.py

def coxeter_spectral(self):
    """Certified Coxeter spectral report (Plan 58 / R20): exact ZZ[x] cyclotomic
    factorization with Phi_n labels, cyclotomic / quasi-unipotent verdict, finite
    Coxeter order (Phi^m = I) or None with an honest reason, exact outside-unit-
    circle root count, and the spectral radius / Mahler measure as CERTIFIED
    ALGEBRAIC NUMBERS (minimal polynomial + rational isolating interval) -- never a
    float. Any field that refuses on this input is captured per-field, never a
    crash."""
    from quiverlab.invariants.coxeter_spectral import coxeter_spectral
    return coxeter_spectral(self)

crosscheck

crosscheck(what='hochschild', *args, **kwargs)

Independently recompute an invariant via the optional QPA backend and compare (spec §5 c.12). Requires pip install quiverlab[qpa]; raises QpaUnavailableError otherwise. Examples: A.crosscheck("hochschild", 3) # HH^0..HH^3 vs QPA enveloping route A.crosscheck("module_ext", M, 4) # Ext^0..Ext^4(M,M) vs QPA (self-Ext) Returns a CrosscheckReport; call .assert_agree() to fail loudly on mismatch.

Source code in src/quiverlab/core/algebra.py

def crosscheck(self, what="hochschild", *args, **kwargs):
    """Independently recompute an invariant via the optional QPA backend and
    compare (spec §5 c.12). Requires `pip install quiverlab[qpa]`; raises
    QpaUnavailableError otherwise. Examples:
        A.crosscheck("hochschild", 3)          # HH^0..HH^3 vs QPA enveloping route
        A.crosscheck("module_ext", M, 4)       # Ext^0..Ext^4(M,M) vs QPA (self-Ext)
    Returns a CrosscheckReport; call .assert_agree() to fail loudly on mismatch."""
    from quiverlab.qpa.crosscheck import crosscheck as _cc
    try:
        return _cc(self, what, *args, **kwargs)
    except TypeError as e:
        # A missing required argument (e.g. A.crosscheck() -> the default
        # what='hochschild' still needs `top`) must be a typed refusal naming the
        # argument, never a raw TypeError from Python's argument binding (Wave 5, 5d).
        msg = str(e)
        if "missing" in msg and "argument" in msg:
            raise QuiverlabError(
                f"crosscheck({what!r}) is missing a required argument ({msg})",
                hint="pass the invariant's argument, e.g. "
                     "A.crosscheck('hochschild', top=4) or "
                     "A.crosscheck('module_ext', M, 4)") from e
        raise

cup_products

cup_products(top, engine='auto', max_cells=4000000)

Structure-constant tables of the cup product HH^p (x) HH^q -> HH^{p+q} for every p+q <= top, on the recorded basis. Exact. engine: 'auto' (GF(p) -> bar/tt, else CS for presented algebras, with the CS depth fallback), 'bar' (GF(p) tt facade, loud otherwise), 'cs' (Chouhy-Solotar native diagonal, presented algebras, any Domain).

Source code in src/quiverlab/core/algebra.py

def cup_products(self, top, engine="auto", max_cells=4_000_000):
    """Structure-constant tables of the cup product HH^p (x) HH^q ->
    HH^{p+q} for every p+q <= top, on the recorded basis. Exact. engine:
    'auto' (GF(p) -> bar/tt, else CS for presented algebras, with the CS
    depth fallback), 'bar' (GF(p) tt facade, loud otherwise), 'cs'
    (Chouhy-Solotar native diagonal, presented algebras, any Domain)."""
    return self._product_dispatch("cup", top, engine, max_cells)

cyclic_homology

cyclic_homology(top, max_cells=4000000, with_reps=False)

Dimensions of HC_0..HC_top (Connes (b, B) mixed complex).

GF(p): the fast engine (int64 rank). Any other exact Domain: the generic mixed complex on the normalized bar basis. Both are exponential in top (dim C_n = m*(m-1)^n); max_cells guards the blow-up on BOTH paths, refusing loudly (DepthLimitError) before any matrix is allocated — raise it to compute a bigger case. Works for any unital algebra.

Plan 35 wave 3b — with_reps=True returns (table, payload) where payload carries the explicit HC representatives (basis_classes / chain_basis / differentials / column_structure keyed by str(degree)) captured from the SAME total complex; the default path is byte-unchanged.

Source code in src/quiverlab/core/algebra.py

def cyclic_homology(self, top, max_cells=4_000_000, with_reps=False):
    """Dimensions of HC_0..HC_top (Connes (b, B) mixed complex).

    GF(p): the fast engine (int64 rank). Any other exact Domain: the
    generic mixed complex on the normalized bar basis. Both are exponential
    in ``top`` (dim C_n = m*(m-1)^n); ``max_cells`` guards the blow-up on
    BOTH paths, refusing loudly (DepthLimitError) before any matrix is
    allocated — raise it to compute a bigger case. Works for any unital
    algebra.

    Plan 35 wave 3b — ``with_reps=True`` returns ``(table, payload)`` where
    ``payload`` carries the explicit HC representatives (``basis_classes`` /
    ``chain_basis`` / ``differentials`` / ``column_structure`` keyed by
    ``str(degree)``) captured from the SAME total complex; the default path is
    byte-unchanged."""
    from quiverlab.fields.primefield import PrimeField
    if isinstance(self.domain, PrimeField):
        from quiverlab.engine.adapter import to_engine
        from quiverlab.engine.cyclic import cyclic_homology_dims
        from quiverlab.hochschild.table import HHTable
        p = self.domain.p
        AU = self.unit_adapted()
        E = to_engine(AU)
        res = cyclic_homology_dims(E, top, primes=(p,), with_reps=with_reps,
                                   max_cells=max_cells)
        out, raw = res if with_reps else (res, None)
        dims = [int(d) for d in out[p]]
        table = HHTable(dims, "HC_", repr(self).splitlines()[0],
                        engine="hanlab engine (F_p fast rank)")
        if not with_reps:
            return table
        from quiverlab.hochschild.cyclic_reps import gfp_payload
        return table, gfp_payload(E, AU, top, raw, dims)
    from quiverlab.hochschild.cyclic import cyclic_homology_dims
    if not with_reps:
        return cyclic_homology_dims(self, top, max_cells=max_cells)
    table, raw = cyclic_homology_dims(self, top, max_cells=max_cells, with_reps=True)
    from quiverlab.hochschild.cyclic_reps import generic_payload
    return table, generic_payload(self, top, raw, list(table.dims))

deformation_structure

deformation_structure(budget=None, engine='auto')

The char-0 formal-deformation report (Plan 78 / R13): infinitesimal HH^2, the primary obstruction [alpha,alpha] in HH^3, the MRRS nilpotent-regime verdict, the order-by-order Maurer-Cartan description on the Hochschild DGLA C(A), the rad^2=0 dg-Lie certificate, and a display-only presented deformed algebra A_alpha with its Ext-algebra summary. Over char p the field-general HH^2/HH^3 block is returned behind the char-0 caveat. Returns a frozen Deformations.

Source code in src/quiverlab/core/algebra.py

def deformation_structure(self, budget=None, engine="auto"):
    """The char-0 formal-deformation report (Plan 78 / R13): infinitesimal HH^2, the
    primary obstruction [alpha,alpha] in HH^3, the MRRS nilpotent-regime verdict, the
    order-by-order Maurer-Cartan description on the Hochschild DGLA C(A), the rad^2=0
    dg-Lie certificate, and a display-only presented deformed algebra A_alpha with its
    Ext-algebra summary. Over char p the field-general HH^2/HH^3 block is returned
    behind the char-0 caveat. Returns a frozen Deformations."""
    from quiverlab.hochschild.deformations import (
        DEFORM_MAXDIM, deformation_structure)
    return deformation_structure(
        self, budget=DEFORM_MAXDIM if budget is None else budget, engine=engine)

deformed_algebra

deformed_algebra(direction, t='1')

Build the presented deformed algebra A_alpha = kQ/I_alpha for a RADICAL 2-cocycle direction and value t, re-certified admissible + flat (Plan 78 / RRRV). Loud on a unit / non-admissible / non-flat direction. Returns an Algebra.

Source code in src/quiverlab/core/algebra.py

def deformed_algebra(self, direction, t="1"):
    """Build the presented deformed algebra A_alpha = kQ/I_alpha for a RADICAL
    2-cocycle direction and value t, re-certified admissible + flat (Plan 78 / RRRV).
    Loud on a unit / non-admissible / non-flat direction. Returns an Algebra."""
    from quiverlab.hochschild.deformations import deformed_algebra
    return deformed_algebra(self, direction, t=t)

degeneration_order

degeneration_order(d, *, budget=256)

The degeneration (= hom) order poset of all iso-classes of dimension vector d, for a representation-FINITE algebra (Plan 49 / C8). Returns a DegenerationPoset; complete iff rep-finite, else a loud status (never a silent partial poset).

Source code in src/quiverlab/core/algebra.py

def degeneration_order(self, d, *, budget=256):
    """The degeneration (= hom) order poset of all iso-classes of dimension
    vector d, for a representation-FINITE algebra (Plan 49 / C8). Returns a
    DegenerationPoset; complete iff rep-finite, else a loud status (never a
    silent partial poset)."""
    from quiverlab.modules.degeneration import degeneration_order
    return degeneration_order(self, d, budget=budget)

dominant_dimension

dominant_dimension(bound=32)

Dominant dimension: the count of leading projective terms in a minimal injective coresolution of the regular module, infinite iff self-injective (Plan 40). A DominantDimension: exact value, certified lower bound, or a certified infinity -- never a bare number the engine did not resolve.

Source code in src/quiverlab/core/algebra.py

def dominant_dimension(self, bound=32):
    """Dominant dimension: the count of leading projective terms in a minimal
    injective coresolution of the regular module, ``infinite`` iff self-injective
    (Plan 40). A ``DominantDimension``: exact value, certified lower bound, or a
    certified infinity -- never a bare number the engine did not resolve."""
    from quiverlab.modules.homdims import dominant_dimension
    return dominant_dimension(self, bound=bound)

draw

draw(file=None)

Draw the quiver (matplotlib): vertices by depth, loops as self-arcs, parallel arrows fanned out, the relation list below (spec §3.7). Returns the Figure; pass file="A.png"/"A.svg" to also save it.

Source code in src/quiverlab/core/algebra.py

def draw(self, file=None):
    """Draw the quiver (matplotlib): vertices by depth, loops as self-arcs,
    parallel arrows fanned out, the relation list below (spec §3.7). Returns
    the Figure; pass file="A.png"/"A.svg" to also save it."""
    if self.quiver is None:
        from quiverlab.errors import QuiverlabError
        raise QuiverlabError(
            "this Algebra has no quiver to draw",
            hint="build it via Quiver.algebra(...) rather than from_structure_constants")
    from quiverlab.viz.draw import draw_quiver
    return draw_quiver(self.quiver, self.relations or [], file=file)

dynkin_type

dynkin_type()

Orientation-blind Dynkin / Euclidean type of the underlying quiver: ("A"|"D"|"E"|"~A"|"~D"|"~E", n) or None (Plan 38 / C2). Loud if this algebra has no quiver presentation.

Source code in src/quiverlab/core/algebra.py

def dynkin_type(self):
    """Orientation-blind Dynkin / Euclidean type of the underlying quiver:
    ("A"|"D"|"E"|"~A"|"~D"|"~E", n) or None (Plan 38 / C2). Loud if this
    algebra has no quiver presentation."""
    if self.quiver is None:
        from quiverlab.errors import QuiverlabError
        raise QuiverlabError(
            "dynkin_type needs the quiver presentation",
            hint="build the algebra via Quiver.algebra(...); structure-constant "
                 "algebras carry no quiver")
    from quiverlab.invariants.dynkin_type import dynkin_type
    return dynkin_type(self.quiver)

enveloping

enveloping()

The enveloping algebra A^e = A (x) A^op as a first-class bound quiver Algebra (product quiver, present_from_pi-certified dim = (dim A)^2, Plan 73 / R7). The first first-class enveloping algebra in quiverlab -- the Hochschild engines only handle A^e internally.

Source code in src/quiverlab/core/algebra.py

def enveloping(self):
    """The enveloping algebra ``A^e = A (x) A^op`` as a first-class bound quiver
    Algebra (product quiver, ``present_from_pi``-certified ``dim = (dim A)^2``,
    Plan 73 / R7). The first first-class enveloping algebra in quiverlab -- the
    Hochschild engines only handle ``A^e`` internally."""
    from quiverlab.families.extension import enveloping_algebra
    return enveloping_algebra(self)

euler_form

euler_form(d, e)

Euler bilinear form = d C^{-1} e^T on integer dimension vectors (vertex order); for finite gl.dim, sum (-1)^i dim Ext^i (Plan 38 / C2).

Source code in src/quiverlab/core/algebra.py

def euler_form(self, d, e):
    """Euler bilinear form <d, e> = d C^{-1} e^T on integer dimension vectors
    (vertex order); for finite gl.dim, sum (-1)^i dim Ext^i (Plan 38 / C2)."""
    from quiverlab.invariants.forms import euler_form
    return euler_form(self, d, e)

exceptional_sequences

exceptional_sequences(budget=100000, transitive='auto')

The complete classical exceptional sequences of this hereditary algebra (Plan 65 / R28): the backward-orthogonality enumeration, the braid-orbit transitivity certificate, and the Dynkin closed-form count n! h^n / |W|. Hereditary + representation-finite scope; loud refusal otherwise. Returns an :class:~quiverlab.modules.exceptional.ExcSeqReport.

Source code in src/quiverlab/core/algebra.py

def exceptional_sequences(self, budget=100_000, transitive="auto"):
    """The complete classical exceptional sequences of this **hereditary** algebra
    (Plan 65 / R28): the backward-orthogonality enumeration, the braid-orbit
    transitivity certificate, and the Dynkin closed-form count ``n! h^n / |W|``.
    Hereditary + representation-finite scope; loud refusal otherwise. Returns an
    :class:`~quiverlab.modules.exceptional.ExcSeqReport`."""
    from quiverlab.modules.exceptional import exceptional_sequences
    return exceptional_sequences(self, budget=budget, transitive=transitive)

exchange_graph

exchange_graph(budget_pairs=512)

The support tau-tilting exchange graph (Plan 45 / C4): BFS from (A, 0) via AIR mutation, n-regular and g-matrix-deduped. Complete iff tau-tilting-finite, else a LOUD budget cap (.is_complete, .status) -- the honest semi-decision contract mirroring the AR quiver.

Source code in src/quiverlab/core/algebra.py

def exchange_graph(self, budget_pairs=512):
    """The support tau-tilting exchange graph (Plan 45 / C4): BFS from ``(A, 0)`` via
    AIR mutation, n-regular and g-matrix-deduped. Complete iff tau-tilting-finite, else
    a LOUD budget cap (``.is_complete``, ``.status``) -- the honest semi-decision
    contract mirroring the AR quiver."""
    from quiverlab.tautilting.mutation import exchange_graph
    return exchange_graph(self, budget_pairs=budget_pairs)

ext

ext(M, N, n)

dim Ext^n_A(M, N) for right A-modules M, N (spec §3.6).

Source code in src/quiverlab/core/algebra.py

def ext(self, M, N, n):
    """dim Ext^n_A(M, N) for right A-modules M, N (spec §3.6)."""
    from quiverlab.modules.ext import ext
    return ext(self, M, N, n)

ext_algebra

ext_algebra(top=6)

The Yoneda / Ext-algebra E(A) = Ext^*_A(A/J, A/J) as a graded quiver-with-relations presentation over R = k^{Q_0}, through degree top (or complete through gl.dim when finite); a YonedaPresentation (Plan 27).

Source code in src/quiverlab/core/algebra.py

def ext_algebra(self, top=6):
    """The Yoneda / Ext-algebra E(A) = Ext^*_A(A/J, A/J) as a graded
    quiver-with-relations presentation over R = k^{Q_0}, through degree `top`
    (or complete through gl.dim when finite); a YonedaPresentation (Plan 27)."""
    from quiverlab.modules.ext_algebra import ext_algebra
    return ext_algebra(self, top)

finitistic_certificate

finitistic_certificate(bound=32)

A Lat-Igusa-Todorov finitistic certificate (Plan 53 / R23c): a proof-carrying certified finite findim upper bound from a decidable LIT family (self-injective / Iwanaga-Gorenstein / finite-phidim), or an honest None (no known decision procedure in general). A :class:~quiverlab.modules.homdims.LITCertificate.

Source code in src/quiverlab/core/algebra.py

def finitistic_certificate(self, bound=32):
    """A Lat-Igusa-Todorov finitistic certificate (Plan 53 / R23c): a proof-carrying
    certified finite ``findim`` upper bound from a decidable LIT family (self-injective
    / Iwanaga-Gorenstein / finite-phidim), or an honest ``None`` (no known decision
    procedure in general). A :class:`~quiverlab.modules.homdims.LITCertificate`."""
    from quiverlab.modules.homdims import lit_finitistic_certificate
    return lit_finitistic_certificate(self, bound=bound)

finitistic_dimension_bounds

finitistic_dimension_bounds(bound=32)

Finitistic dimension findim A, bracketed honestly (Plan 40): a rigorous lower bound (a finite pd actually found) and an upper bound = gl.dim when finite (findim = gl.dim), else None (no folklore number). A FinitisticBounds.

Source code in src/quiverlab/core/algebra.py

def finitistic_dimension_bounds(self, bound=32):
    """Finitistic dimension findim A, bracketed honestly (Plan 40): a rigorous
    lower bound (a finite pd actually found) and an upper bound = gl.dim when
    finite (findim = gl.dim), else None (no folklore number). A
    ``FinitisticBounds``."""
    from quiverlab.modules.homdims import finitistic_dimension_bounds
    return finitistic_dimension_bounds(self, bound=bound)

form_type

form_type()

'finite' / 'tame' / 'wild' by exact definiteness of the Tits form; a representation-type theorem for hereditary algebras, the signature otherwise (Plan 38 / C2).

Source code in src/quiverlab/core/algebra.py

def form_type(self):
    """'finite' / 'tame' / 'wild' by exact definiteness of the Tits form; a
    representation-type theorem for hereditary algebras, the signature
    otherwise (Plan 38 / C2)."""
    from quiverlab.invariants.forms import form_type
    return form_type(self)

fractional_calabi_yau_dimension

fractional_calabi_yau_dimension(**kw)

The stable-category fractional Calabi-Yau dimension (m, ell) of a self-injective algebra (Plan 53 / R24): S = Omega.nu, Sigma = Omega^{-1}, certified at the weak-on-generators tier (Ivanov-Volkov criterion; bounded search + loud budget). RAISES for non-self-injective A. A :class:~quiverlab.modules.fractional_cy.FractionalCY.

Source code in src/quiverlab/core/algebra.py

def fractional_calabi_yau_dimension(self, **kw):
    """The stable-category fractional Calabi-Yau dimension ``(m, ell)`` of a
    self-injective algebra (Plan 53 / R24): ``S = Omega.nu``, ``Sigma = Omega^{-1}``,
    certified at the weak-on-generators tier (Ivanov-Volkov criterion; bounded search
    + loud budget). RAISES for non-self-injective ``A``. A
    :class:`~quiverlab.modules.fractional_cy.FractionalCY`."""
    from quiverlab.modules.fractional_cy import fractional_calabi_yau
    return fractional_calabi_yau(self, **kw)

fundamental_group

fundamental_group(base=None)

The presentation fundamental group pi1(Q, I): a finite presentation (generators = non-tree arrows, relators from the minimal relations of I) with its abelianization pi1^ab by exact integer Smith normal form. Loud refusal on presentation-less input. NOT the intrinsic (grading) group.

Source code in src/quiverlab/core/algebra.py

def fundamental_group(self, base=None):
    """The presentation fundamental group pi1(Q, I): a finite presentation
    (generators = non-tree arrows, relators from the minimal relations of I)
    with its abelianization pi1^ab by exact integer Smith normal form. Loud
    refusal on presentation-less input. NOT the intrinsic (grading) group."""
    from quiverlab.invariants.coverings import fundamental_group
    return fundamental_group(self, base=base)

gabriel_quiver

gabriel_quiver()

The Gabriel (Ext) quiver of this algebra (vertices = iso classes of primitive idempotents, arrows off rad/rad^2 of the basic algebra) (Plan 44).

Source code in src/quiverlab/core/algebra.py

def gabriel_quiver(self):
    """The Gabriel (Ext) quiver of this algebra (vertices = iso classes of primitive
    idempotents, arrows off ``rad/rad^2`` of the basic algebra) (Plan 44)."""
    from quiverlab.core.basic import gabriel_quiver
    return gabriel_quiver(self)

gerstenhaber_brackets

gerstenhaber_brackets(top, engine='auto', max_cells=4000000)

Structure-constant tables of the Gerstenhaber bracket HH^p (x) HH^q -> HH^{p+q-1} for pairs p, q >= 1 with p+q-1 <= top. Same engine semantics as cup_products/cap_products (Plan 51): 'auto' (GF(p) -> bar/tt in-window, records the served window; else CS-native for presented algebras, with the CS depth fallback), 'bar' (GF(p) tt facade, loud otherwise), 'cs' (Chouhy-Solotar homotopy-lifting bracket, presented algebras, any exact Domain, past the bar window). The degree-0 insertion action is out of scope.

Source code in src/quiverlab/core/algebra.py

def gerstenhaber_brackets(self, top, engine="auto", max_cells=4_000_000):
    """Structure-constant tables of the Gerstenhaber bracket HH^p (x)
    HH^q -> HH^{p+q-1} for pairs p, q >= 1 with p+q-1 <= top. Same engine
    semantics as cup_products/cap_products (Plan 51): 'auto' (GF(p) -> bar/tt
    in-window, records the served window; else CS-native for presented algebras,
    with the CS depth fallback), 'bar' (GF(p) tt facade, loud otherwise), 'cs'
    (Chouhy-Solotar homotopy-lifting bracket, presented algebras, any exact
    Domain, past the bar window). The degree-0 insertion action is out of scope."""
    return self._product_dispatch("bracket", top, engine, max_cells)

global_dimension

global_dimension()

Global dimension: exact value or a labeled certified lower bound (spec §3.5).

Source code in src/quiverlab/core/algebra.py

def global_dimension(self):
    """Global dimension: exact value or a labeled certified lower bound (spec §3.5)."""
    from quiverlab.modules.ext import global_dimension
    return global_dimension(self)

gorenstein_dimension

gorenstein_dimension(bound=32)

Gorenstein data: the injective dimension of the regular module on both sides (Plan 40). A GorensteinDimension with three-valued is_gorenstein True/None (never a bare False).

Source code in src/quiverlab/core/algebra.py

def gorenstein_dimension(self, bound=32):
    """Gorenstein data: the injective dimension of the regular module on both
    sides (Plan 40). A ``GorensteinDimension`` with three-valued
    ``is_gorenstein`` True/None (never a bare False)."""
    from quiverlab.modules.homdims import gorenstein_dimension
    return gorenstein_dimension(self, bound=bound)

han_transport

han_transport(new_arrows, *, side='auto', nilp_cap=8, pd_cap=16, hh_top=None)

Transport Han's conjecture across B subset A (CLMS Thm 3.1/4.6, Plan 73 / R7). Labels the claim by the exact row of the injection/isomorphism LADDER (bounded => iso; (i)+(ii) => ordinary injection; (i) => mixed-coeff injection). Returns a HanTransport; the self-cert gate is the injection bound dim HH_m(B) <= dim HH_m(A), equality only under "bounded".

Source code in src/quiverlab/core/algebra.py

def han_transport(self, new_arrows, *, side="auto", nilp_cap=8, pd_cap=16,
                  hh_top=None):
    """Transport Han's conjecture across ``B subset A`` (CLMS Thm 3.1/4.6, Plan
    73 / R7). Labels the claim by the exact row of the injection/isomorphism
    LADDER (bounded => iso; (i)+(ii) => ordinary injection; (i) => mixed-coeff
    injection). Returns a ``HanTransport``; the self-cert gate is the injection
    bound ``dim HH_m(B) <= dim HH_m(A)``, equality only under ``"bounded"``."""
    from quiverlab.invariants.han import han_transport
    return han_transport(self, new_arrows, side=side, nilp_cap=nilp_cap,
                         pd_cap=pd_cap, hh_top=hh_top)

hh1_lie_structure

hh1_lie_structure(budget=None, require_char0=False)

HH^1(A) = Der(A)/Inn(A) as a Lie algebra (Plan 70 / R11): dimension, bracket structure constants, derived / lower-central series, and the solvable / nilpotent / abelian / perfect verdicts over ANY exact field; over characteristic 0 also the solvable radical, Levi decomposition, sl2-count and toral rank. Field-general via the algebra's own structure constants -- no resolution. Loud over budget.

Source code in src/quiverlab/core/algebra.py

def hh1_lie_structure(self, budget=None, require_char0=False):
    """HH^1(A) = Der(A)/Inn(A) as a Lie algebra (Plan 70 / R11): dimension,
    bracket structure constants, derived / lower-central series, and the
    solvable / nilpotent / abelian / perfect verdicts over ANY exact field;
    over characteristic 0 also the solvable radical, Levi decomposition,
    sl2-count and toral rank. Field-general via the algebra's own structure
    constants -- no resolution. Loud over budget."""
    from quiverlab.invariants.hh1_lie import DEFAULT_MAXDIM, hh1_lie_structure
    return hh1_lie_structure(
        self, budget=DEFAULT_MAXDIM if budget is None else budget,
        require_char0=require_char0)

hh_lie_module

hh_lie_module(top, budget=None, max_cells=4000000)

HH^*(A) as a graded Lie module over HH^1(A) (Plan 71 / R12): per degree 0..top the action matrices rho_n(D) = the Gerstenhaber degree-1 Lie derivative (the field-general primitive, over any exact field), the self-certified module axiom rho_n([D,E]) = [rho_n(D),rho_n(E)] and inner-acts-zero, plus -- over characteristic 0 -- the weight/torus decomposition and the indecomposable Lie-module summands (the latter governed independently by decompose's own char guard). Builds on HH^1 = Der/Inn (Plan 70); no resolution engine. Returns a frozen HHLieModule.

Source code in src/quiverlab/core/algebra.py

def hh_lie_module(self, top, budget=None, max_cells=4_000_000):
    """HH^*(A) as a graded Lie module over HH^1(A) (Plan 71 / R12): per degree
    0..top the action matrices rho_n(D) = the Gerstenhaber degree-1 Lie derivative
    (the field-general primitive, over any exact field), the self-certified module
    axiom rho_n([D,E]) = [rho_n(D),rho_n(E)] and inner-acts-zero, plus -- over
    characteristic 0 -- the weight/torus decomposition and the indecomposable
    Lie-module summands (the latter governed independently by decompose's own char
    guard). Builds on HH^1 = Der/Inn (Plan 70); no resolution engine. Returns a
    frozen HHLieModule."""
    from quiverlab.hochschild.lie_module import DEFAULT_MAXDIM, lie_module_action
    return lie_module_action(
        self, top, budget=DEFAULT_MAXDIM if budget is None else budget,
        max_cells=max_cells)

hochschild_bB_ss

hochschild_bB_ss(top, max_cells=4000000)

The Hochschild (b, B) spectral sequence (Plan 42): the first-quadrant (b, B) bicomplex whose total complex computes cyclic homology, returned as a pre-certified :class:~quiverlab.specseq.pages.SpectralSequence (E_inf totals == HC_*(A)). The exponential bar basis is guarded by max_cells (loud DepthLimitError up front). Works over any exact Domain.

Source code in src/quiverlab/core/algebra.py

def hochschild_bB_ss(self, top, max_cells=4_000_000):
    """The Hochschild ``(b, B)`` spectral sequence (Plan 42): the first-quadrant
    ``(b, B)`` bicomplex whose total complex computes cyclic homology, returned
    as a pre-certified :class:`~quiverlab.specseq.pages.SpectralSequence`
    (``E_inf`` totals == ``HC_*(A)``). The exponential bar basis is guarded by
    ``max_cells`` (loud ``DepthLimitError`` up front). Works over any exact
    Domain."""
    from quiverlab.specseq.presets import hochschild_bB_ss
    return hochschild_bB_ss(self, top, max_cells=max_cells)

hochschild_cohomology

hochschild_cohomology(top, max_cells=4000000, engine='auto', auto_cs=False, coefficients=None, relative_to=None, verbose=None, trace=None)

Dimensions of HH^0..HH^top, exact. engine: 'auto' (fast over GF(p), bar otherwise), 'bar' (pure, any field), 'fast' (GF(p) only, loud otherwise), 'cs' (Chouhy-Solotar, any admissible presentation over any field). Set auto_cs=True to let engine='auto' route non-monomial admissible algebras to CS up front. Default 'auto' additionally FALLS BACK to CS at the exact depth where the bar/fast route would raise DepthLimitError, for quiver-presented algebras (recorded in the dispatch trace; in-window results byte-unchanged; presentation-less algebras still refuse). verbose: per-call override of quiverlab.verbose (None defers to it); when on, a recorder captures the worked steps. trace: an explicit event sink (list or Trace) the engines fill with resolution/rank/dispatch events; passing it is programmatic and does not by itself request a file.

Source code in src/quiverlab/core/algebra.py

def hochschild_cohomology(self, top, max_cells=4_000_000, engine="auto",
                          auto_cs=False, coefficients=None, relative_to=None,
                          verbose=None, trace=None):
    """Dimensions of HH^0..HH^top, exact. engine: 'auto' (fast over GF(p),
    bar otherwise), 'bar' (pure, any field), 'fast' (GF(p) only, loud otherwise),
    'cs' (Chouhy-Solotar, any admissible presentation over any field). Set
    auto_cs=True to let engine='auto' route non-monomial admissible algebras to CS
    up front. Default 'auto' additionally FALLS BACK to CS at the exact depth
    where the bar/fast route would raise DepthLimitError, for quiver-presented
    algebras (recorded in the dispatch trace; in-window results byte-unchanged;
    presentation-less algebras still refuse). verbose: per-call override
    of quiverlab.verbose (None defers to it); when on, a recorder captures the
    worked steps. trace: an explicit event sink (list or Trace) the engines fill
    with resolution/rank/dispatch events; passing it is programmatic and does not
    by itself request a file."""
    import quiverlab
    from quiverlab.hochschild.bar import hochschild_cohomology_dims
    from quiverlab.hochschild.table import HHTable
    from quiverlab.trace.events import Dispatch
    from quiverlab.trace.recorder import Trace, resolve_verbose

    if engine not in ("auto", "bar", "fast", "cs", "ghms"):
        raise QuiverlabError(f"unknown engine {engine!r}",
                             hint="choose 'auto', 'bar', 'fast', 'cs', or 'ghms'")
    if engine == "ghms":
        # Plan 75 / R10: the closed-form GHMS route for a CERTIFIED-KOSZUL algebra.
        # Domain-general (unlike the GF(p)-only syzygy engine) and it never searches
        # for syzygies. The Koszul gate is three-valued and refuses loudly; `auto` is
        # deliberately NOT routed here, so every existing result stays byte-identical.
        from quiverlab.hochschild.koszul_ghms import (
            _GHMS_CITATIONS, ghms_cohomology_dims, ghms_homology_dims)
        fn = ghms_cohomology_dims if True else ghms_homology_dims
        return HHTable(dims=fn(self, top), kind="cohomology",
                       algebra_repr=repr(self),
                       engine="GHMS comultiplicative Koszul resolution",
                       references=_GHMS_CITATIONS)
    self._check_coefficients(engine, coefficients)
    if relative_to is not None:
        table = self._relative_route("coh", top, max_cells, coefficients, relative_to)
        table.references = self.citations()
        if coefficients is not None:
            table.coefficients = coefficients.describe()
        return table
    want = resolve_verbose(verbose, quiverlab.verbose)
    rec = trace if trace is not None else (Trace() if want else None)
    if self._route_to_cs(engine, auto_cs):
        from quiverlab.resolutions_cs.homology import cs_cohomology_dims
        if rec is not None:
            rec.append(Dispatch(
                route="chouhy-solotar",
                reason="general Chouhy-Solotar resolution over the admissible presentation",
                n_relations=len(self.relations or ())))
        table = cs_cohomology_dims(self, top, max_cells=max_cells, trace=rec,
                                   coefficients=coefficients)  # CS fills rec
    elif self._use_fast_engine(engine, coefficients):
        from quiverlab.engine.adapter import engine_cohomology_dims
        if rec is not None:
            rec.append(Dispatch(
                route="hanlab fast GF(p) rank",
                reason="domain is a prime field; the exact mod-p rank engine applies",
                n_relations=len(self.relations or ())))
        try:
            dims = engine_cohomology_dims(self, top, max_cells=max_cells)  # plain list[int]
            table = HHTable(dims, "HH^", repr(self).splitlines()[0],
                            engine="hanlab engine (F_p fast rank)")     # WRAP the list
        except DepthLimitError:
            if engine != "auto" or self.quiver is None:
                raise
            table = self._cs_depth_fallback("coh", rec, top, max_cells,
                                            "fast GF(p) bar basis", coefficients=coefficients)
    else:
        if rec is not None:
            rec.append(Dispatch(
                route="normalized bar complex",
                reason="domain is not a prime field; the exact bar oracle is used",
                n_relations=len(self.relations or ())))
        try:
            table = hochschild_cohomology_dims(self, top, max_cells=max_cells,
                                               trace=rec, coefficients=coefficients)
        except DepthLimitError:
            if engine != "auto" or self.quiver is None:
                raise
            table = self._cs_depth_fallback("coh", rec, top, max_cells,
                                            "bar oracle", coefficients=coefficients)
    table.references = self.citations()   # FROZEN contract (family+engine keys); Task 11 must NOT change it
    if coefficients is not None:
        table.coefficients = coefficients.describe()   # provenance (only when non-None)
    if want and trace is None and rec is not None:
        from quiverlab.trace.provenance import references_for, resolve_references
        from quiverlab.trace.writer import write_trace
        # References SECTION = engine keys implied by the trace's Dispatch, resolved
        # through bibliography(); table.references stays self.citations() (untouched).
        write_trace(list(rec), table, algebra=self, kind="HH^", top=top,
                    references=resolve_references(references_for(rec)))
    return table

hochschild_homology

hochschild_homology(top, max_cells=4000000, engine='auto', auto_cs=False, coefficients=None, relative_to=None, verbose=None, trace=None)

Dimensions of HH_0..HH_top, exact. Same engine semantics as cohomology (including 'cs', auto_cs, coefficients, relative_to, verbose, and the trace event sink).

Source code in src/quiverlab/core/algebra.py

def hochschild_homology(self, top, max_cells=4_000_000, engine="auto",
                        auto_cs=False, coefficients=None, relative_to=None,
                        verbose=None, trace=None):
    """Dimensions of HH_0..HH_top, exact. Same engine semantics as cohomology
    (including 'cs', auto_cs, coefficients, relative_to, verbose, and the trace
    event sink)."""
    import quiverlab
    from quiverlab.hochschild.bar import hochschild_homology_dims
    from quiverlab.hochschild.table import HHTable
    from quiverlab.trace.events import Dispatch
    from quiverlab.trace.recorder import Trace, resolve_verbose

    if engine not in ("auto", "bar", "fast", "cs", "ghms"):
        raise QuiverlabError(f"unknown engine {engine!r}",
                             hint="choose 'auto', 'bar', 'fast', 'cs', or 'ghms'")
    if engine == "ghms":
        # Plan 75 / R10: the closed-form GHMS route for a CERTIFIED-KOSZUL algebra.
        # Domain-general (unlike the GF(p)-only syzygy engine) and it never searches
        # for syzygies. The Koszul gate is three-valued and refuses loudly; `auto` is
        # deliberately NOT routed here, so every existing result stays byte-identical.
        from quiverlab.hochschild.koszul_ghms import (
            _GHMS_CITATIONS, ghms_cohomology_dims, ghms_homology_dims)
        fn = ghms_cohomology_dims if False else ghms_homology_dims
        return HHTable(dims=fn(self, top), kind="homology",
                       algebra_repr=repr(self),
                       engine="GHMS comultiplicative Koszul resolution",
                       references=_GHMS_CITATIONS)
    self._check_coefficients(engine, coefficients)
    if relative_to is not None:
        table = self._relative_route("hom", top, max_cells, coefficients, relative_to)
        table.references = self.citations()
        if coefficients is not None:
            table.coefficients = coefficients.describe()
        return table
    want = resolve_verbose(verbose, quiverlab.verbose)
    rec = trace if trace is not None else (Trace() if want else None)
    if self._route_to_cs(engine, auto_cs):
        from quiverlab.resolutions_cs.homology import cs_homology_dims
        if rec is not None:
            rec.append(Dispatch(
                route="chouhy-solotar",
                reason="general Chouhy-Solotar resolution over the admissible presentation",
                n_relations=len(self.relations or ())))
        table = cs_homology_dims(self, top, max_cells=max_cells, trace=rec,
                                 coefficients=coefficients)  # CS fills rec
    elif self._use_fast_engine(engine, coefficients):
        from quiverlab.engine.adapter import engine_homology_dims
        if rec is not None:
            rec.append(Dispatch(
                route="hanlab fast GF(p) rank",
                reason="domain is a prime field; the exact mod-p rank engine applies",
                n_relations=len(self.relations or ())))
        try:
            dims = engine_homology_dims(self, top, max_cells=max_cells)  # plain list[int]
            table = HHTable(dims, "HH_", repr(self).splitlines()[0],
                            engine="hanlab engine (F_p fast rank)")   # WRAP the list
        except DepthLimitError:
            if engine != "auto" or self.quiver is None:
                raise
            table = self._cs_depth_fallback("hom", rec, top, max_cells,
                                            "fast GF(p) bar basis", coefficients=coefficients)
    else:
        if rec is not None:
            rec.append(Dispatch(
                route="normalized bar complex",
                reason="domain is not a prime field; the exact bar oracle is used",
                n_relations=len(self.relations or ())))
        try:
            table = hochschild_homology_dims(self, top, max_cells=max_cells,
                                             trace=rec, coefficients=coefficients)
        except DepthLimitError:
            if engine != "auto" or self.quiver is None:
                raise
            table = self._cs_depth_fallback("hom", rec, top, max_cells,
                                            "bar oracle", coefficients=coefficients)
    table.references = self.citations()   # FROZEN contract (family+engine keys); Task 11 must NOT change it
    if coefficients is not None:
        table.coefficients = coefficients.describe()   # provenance (only when non-None)
    if want and trace is None and rec is not None:
        from quiverlab.trace.provenance import references_for, resolve_references
        from quiverlab.trace.writer import write_trace
        # References SECTION = engine keys implied by the trace's Dispatch, resolved
        # through bibliography(); table.references stays self.citations() (untouched).
        write_trace(list(rec), table, algebra=self, kind="HH_", top=top,
                    references=resolve_references(references_for(rec)))
    return table

hom

hom(M, N)

dim Hom_A(M, N) for right A-modules M, N (spec §3.6).

Source code in src/quiverlab/core/algebra.py

def hom(self, M, N):
    """dim Hom_A(M, N) for right A-modules M, N (spec §3.6)."""
    from quiverlab.modules.hom import hom_dim
    return hom_dim(M, N)

hom_basis

hom_basis(M, N)

A basis of Hom_A(M, N) as validated ModuleHom objects (Plan 37 / C1). A.hom(M, N) is len(A.hom_basis(M, N)).

Source code in src/quiverlab/core/algebra.py

def hom_basis(self, M, N):
    """A basis of Hom_A(M, N) as validated ModuleHom objects (Plan 37 / C1).
    `A.hom(M, N)` is `len(A.hom_basis(M, N))`."""
    from quiverlab.modules.morphism import hom_basis
    return hom_basis(M, N)

incidence_cohomology

incidence_cohomology(top, field=None)

HH^*(kP) via the ORDER COMPLEX, for an algebra built as an incidence algebra: HH^n(kP) = H^n(Delta(P); k) (Cibils 1989, generalizing Gerstenhaber-Schack 1983 from face posets to arbitrary finite posets; Plan 75 / R9).

Far smaller than the general route -- the cochain complex is indexed by CHAINS of P rather than by the enveloping algebra (kP)^e -- and it reports the integral torsion that makes HH^* characteristic-dependent. Refuses LOUDLY unless the algebra carries poset provenance (this method never guesses that a presentation is an incidence algebra).

Source code in src/quiverlab/core/algebra.py

def incidence_cohomology(self, top, field=None):
    """``HH^*(kP)`` via the ORDER COMPLEX, for an algebra built as an incidence
    algebra: ``HH^n(kP) = H^n(Delta(P); k)`` (Cibils 1989, generalizing
    Gerstenhaber-Schack 1983 from face posets to arbitrary finite posets; Plan 75 / R9).

    Far smaller than the general route -- the cochain complex is indexed by CHAINS of
    ``P`` rather than by the enveloping algebra ``(kP)^e`` -- and it reports the
    integral torsion that makes ``HH^*`` characteristic-dependent. Refuses LOUDLY
    unless the algebra carries poset provenance (this method never guesses that a
    presentation is an incidence algebra).
    """
    from quiverlab.hochschild.simplicial import incidence_cohomology
    return incidence_cohomology(self, top, field=field)

inert_arrows

inert_arrows()

The inert arrows of A — arrows in no minimal relation of I (CLMS Def. 3.1, Plan 72 / R6). Structure-constant-only ⇒ loud.

Source code in src/quiverlab/core/algebra.py

def inert_arrows(self):
    """The inert arrows of ``A`` — arrows in no minimal relation of ``I`` (CLMS
    Def. 3.1, Plan 72 / R6). Structure-constant-only ⇒ loud."""
    from quiverlab.hochschild.arrow_removal import inert_arrows
    return inert_arrows(self)

injective

injective(v, side='right')

The indecomposable injective I_v = D(A e_v) (right, default) or the left injective with side="left" (Plan 24).

Source code in src/quiverlab/core/algebra.py

def injective(self, v, side="right"):
    """The indecomposable injective I_v = D(A e_v) (right, default) or the left
    injective with ``side="left"`` (Plan 24)."""
    return self._sided_builder("injective", v, side)

intrinsic_fundamental_group

intrinsic_fundamental_group()

The intrinsic fundamental group (inverse limit over connected gradings): ALWAYS refused loudly -- not bounded-computable (Cibils-Redondo-Solotar). Use fundamental_group() for the presentation group instead.

Source code in src/quiverlab/core/algebra.py

def intrinsic_fundamental_group(self):
    """The intrinsic fundamental group (inverse limit over connected gradings):
    ALWAYS refused loudly -- not bounded-computable (Cibils-Redondo-Solotar).
    Use fundamental_group() for the presentation group instead."""
    from quiverlab.invariants.coverings import intrinsic_fundamental_group
    return intrinsic_fundamental_group(self)

is_ada

is_ada(budget=256)

True iff this algebra is ada -- every indecomposable projective and injective lies in L_A u R_A (ACLV Def 2.1); the ada rung of :meth:recognizer_ladder. Raises a typed QuiverlabError (never a raw KeyError) when the ladder refuses; the three-valued view is on :meth:recognizer_ladder.

Source code in src/quiverlab/core/algebra.py

def is_ada(self, budget=256):
    """True iff this algebra is ada -- every indecomposable projective and injective lies
    in ``L_A u R_A`` (ACLV Def 2.1); the ``ada`` rung of :meth:`recognizer_ladder`. Raises
    a typed ``QuiverlabError`` (never a raw KeyError) when the ladder refuses; the
    three-valued view is on :meth:`recognizer_ladder`."""
    return self._recognizer_verdict("ada", budget)

is_basic

is_basic()

True for every kQ/I presentation (basic algebra); loud on presentation-less input.

Source code in src/quiverlab/core/algebra.py

def is_basic(self):
    """True for every kQ/I presentation (basic algebra); loud on
    presentation-less input."""
    from quiverlab.invariants.recognizers import is_basic
    return is_basic(self)

is_exceptional_sequence

is_exceptional_sequence(seq)

True iff seq is a classical exceptional sequence over this hereditary algebra (Plan 65 / R28): each term a rigid brick, no backward Hom/Ext (i<j => Hom(E_j,E_i)=Ext^1(E_j,E_i)=0). Loud non-hereditary refusal.

Source code in src/quiverlab/core/algebra.py

def is_exceptional_sequence(self, seq):
    """True iff ``seq`` is a classical exceptional sequence over this **hereditary**
    algebra (Plan 65 / R28): each term a rigid brick, no backward Hom/Ext (``i<j`` =>
    ``Hom(E_j,E_i)=Ext^1(E_j,E_i)=0``). Loud non-hereditary refusal."""
    from quiverlab.modules.exceptional import is_exceptional_sequence
    return is_exceptional_sequence(self, seq)

is_fractionally_calabi_yau

is_fractionally_calabi_yau(**kw)

True iff the stable category of this self-injective algebra CERTIFIES a fractional Calabi-Yau dimension (Plan 53 / R24). RAISES for non-self-injective.

Source code in src/quiverlab/core/algebra.py

def is_fractionally_calabi_yau(self, **kw):
    """True iff the stable category of this self-injective algebra CERTIFIES a
    fractional Calabi-Yau dimension (Plan 53 / R24). RAISES for non-self-injective."""
    from quiverlab.modules.fractional_cy import is_fractionally_calabi_yau
    return is_fractionally_calabi_yau(self, **kw)

is_frobenius

is_frobenius()

Is the algebra Frobenius? GF(p): engine form search. Other exact Domains: the exact socle criterion on a path-type basis (Plan 19).

Source code in src/quiverlab/core/algebra.py

def is_frobenius(self):
    """Is the algebra Frobenius? GF(p): engine form search. Other exact
    Domains: the exact socle criterion on a path-type basis (Plan 19)."""
    from quiverlab.fields.primefield import PrimeField
    if isinstance(self.domain, PrimeField):
        from quiverlab.engine.adapter import to_engine
        from quiverlab.engine.coxeter import is_frobenius
        return bool(is_frobenius(to_engine(self.unit_adapted()), self.domain.p))
    from quiverlab.invariants.frobenius import is_frobenius_generic
    return is_frobenius_generic(self)

is_gentle

is_gentle()

True iff A is a gentle algebra (string + length-2 ideal + dual one-relation condition).

Source code in src/quiverlab/core/algebra.py

def is_gentle(self):
    """True iff A is a gentle algebra (string + length-2 ideal + dual
    one-relation condition)."""
    from quiverlab.invariants.recognizers import is_gentle
    return is_gentle(self)

is_gorenstein

is_gorenstein(bound=32)

True iff both the right and left injective dimensions of the regular module are finite; None when unresolved within bound (infinity not proven -- never False) (Plan 40).

Source code in src/quiverlab/core/algebra.py

def is_gorenstein(self, bound=32):
    """True iff both the right and left injective dimensions of the regular module
    are finite; None when unresolved within ``bound`` (infinity not proven -- never
    False) (Plan 40)."""
    from quiverlab.modules.homdims import is_gorenstein
    return is_gorenstein(self, bound=bound)

is_hereditary

is_hereditary()

True iff A is hereditary: a path algebra kQ with Q acyclic and no relations (gl.dim <= 1).

Source code in src/quiverlab/core/algebra.py

def is_hereditary(self):
    """True iff A is hereditary: a path algebra kQ with Q acyclic and no
    relations (gl.dim <= 1)."""
    from quiverlab.invariants.recognizers import is_hereditary
    return is_hereditary(self)

is_laura

is_laura(budget=256)

True iff this algebra is laura -- ind A \ (L_A u R_A) is finite (Assem-Coelho); trivially True in representation-finite scope, with the finite complement reported by :meth:recognizer_ladder. Raises a typed QuiverlabError (never a raw KeyError) when the ladder refuses; three-valued view on :meth:recognizer_ladder.

Source code in src/quiverlab/core/algebra.py

def is_laura(self, budget=256):
    """True iff this algebra is laura -- ``ind A \\ (L_A u R_A)`` is finite (Assem-Coelho);
    trivially True in representation-finite scope, with the finite complement reported by
    :meth:`recognizer_ladder`. Raises a typed ``QuiverlabError`` (never a raw KeyError)
    when the ladder refuses; three-valued view on :meth:`recognizer_ladder`."""
    return self._recognizer_verdict("laura", budget)

is_nakayama

is_nakayama()

True iff the quiver is a union of linear A_n and single oriented cycles (every vertex in/out-degree <= 1).

Source code in src/quiverlab/core/algebra.py

def is_nakayama(self):
    """True iff the quiver is a union of linear A_n and single oriented
    cycles (every vertex in/out-degree <= 1)."""
    from quiverlab.invariants.recognizers import is_nakayama
    return is_nakayama(self)

is_nilpotent_hh1

is_nilpotent_hh1(budget=None)

Is HH^1(A) a nilpotent Lie algebra? Any exact field (Plan 70).

Source code in src/quiverlab/core/algebra.py

def is_nilpotent_hh1(self, budget=None):
    """Is HH^1(A) a nilpotent Lie algebra? Any exact field (Plan 70)."""
    from quiverlab.invariants.hh1_lie import DEFAULT_MAXDIM, is_nilpotent_hh1
    return is_nilpotent_hh1(self, budget=DEFAULT_MAXDIM if budget is None else budget)

is_quasi_hereditary

is_quasi_hereditary(order=None)

A :class:~quiverlab.modules.quasihereditary.QHReport for whether A is quasi-hereditary in the given order (Dlab-Ringel; ORDER-DEPENDENT). Char-clean (Plan 47).

Source code in src/quiverlab/core/algebra.py

def is_quasi_hereditary(self, order=None):
    """A :class:`~quiverlab.modules.quasihereditary.QHReport` for whether ``A`` is
    quasi-hereditary in the given ``order`` (Dlab-Ringel; ORDER-DEPENDENT). Char-clean
    (Plan 47)."""
    from quiverlab.modules.quasihereditary import is_quasi_hereditary
    return is_quasi_hereditary(self, order)

is_quasi_tilted

is_quasi_tilted(budget=256)

True iff this algebra is quasi-tilted -- (QT1) gl.dim <= 2 and (QT2) every indecomposable has pd <= 1 or id <= 1 (Happel-Reiten-Smalo); the quasi_tilted rung of :meth:recognizer_ladder. Raises a typed QuiverlabError (never a raw KeyError) when the ladder refuses; the three-valued view is on :meth:recognizer_ladder.

Source code in src/quiverlab/core/algebra.py

def is_quasi_tilted(self, budget=256):
    """True iff this algebra is quasi-tilted -- (QT1) gl.dim <= 2 and (QT2) every
    indecomposable has pd <= 1 or id <= 1 (Happel-Reiten-Smalo); the ``quasi_tilted`` rung
    of :meth:`recognizer_ladder`. Raises a typed ``QuiverlabError`` (never a raw KeyError)
    when the ladder refuses; the three-valued view is on :meth:`recognizer_ladder`."""
    return self._recognizer_verdict("quasi_tilted", budget)

is_radical_square_zero

is_radical_square_zero()

True iff rad^2 A = 0 (Loewy length <= 2).

Source code in src/quiverlab/core/algebra.py

def is_radical_square_zero(self):
    """True iff rad^2 A = 0 (Loewy length <= 2)."""
    from quiverlab.invariants.recognizers import is_radical_square_zero
    return is_radical_square_zero(self)

is_rigid

is_rigid(M)

Voigt: M is rigid iff Ext^1_A(M, M) = 0 (=> the orbit O_M is open in the module variety) (Plan 49 / C8).

Source code in src/quiverlab/core/algebra.py

def is_rigid(self, M):
    """Voigt: M is rigid iff Ext^1_A(M, M) = 0 (=> the orbit O_M is open in
    the module variety) (Plan 49 / C8)."""
    from quiverlab.invariants.geometry import is_rigid
    return is_rigid(M)

is_selfinjective

is_selfinjective()

True iff every indecomposable projective is injective (self-injective = Frobenius for a f.d. algebra); exact over any field (spec §3.5).

Source code in src/quiverlab/core/algebra.py

def is_selfinjective(self):
    """True iff every indecomposable projective is injective (self-injective =
    Frobenius for a f.d. algebra); exact over any field (spec §3.5)."""
    from quiverlab.modules.ext import is_selfinjective
    return is_selfinjective(self)

is_semisimple

is_semisimple()

True iff A is semisimple (Loewy length 1).

Source code in src/quiverlab/core/algebra.py

def is_semisimple(self):
    """True iff A is semisimple (Loewy length 1)."""
    from quiverlab.invariants.recognizers import is_semisimple
    return is_semisimple(self)

is_shod

is_shod(budget=256)

True iff this algebra is shod -- every indecomposable has pd <= 1 or id <= 1 (Coelho-Lanzilotta), equivalently ind A = L_A u R_A; the shod rung of :meth:recognizer_ladder. Raises a typed QuiverlabError (never a raw KeyError) when the ladder refuses; the three-valued view is on :meth:recognizer_ladder.

Source code in src/quiverlab/core/algebra.py

def is_shod(self, budget=256):
    """True iff this algebra is shod -- every indecomposable has pd <= 1 or id <= 1
    (Coelho-Lanzilotta), equivalently ``ind A = L_A u R_A``; the ``shod`` rung of
    :meth:`recognizer_ladder`. Raises a typed ``QuiverlabError`` (never a raw KeyError)
    when the ladder refuses; the three-valued view is on :meth:`recognizer_ladder`."""
    return self._recognizer_verdict("shod", budget)

is_simply_connected

is_simply_connected(strong='auto', convex_budget=20000)

Three-valued simple-connectivity verdict: True only via decidable sufficient criteria (tree / no-bypass Le Meur / separation), False via a decidable witness (disconnected / oriented cycle / nontrivial pi1^ab), else None (inconclusive, honest per Adian-Rabin). Carries the R16 strongly-simply-connected certificate (the P62 gate). Loud on presentation-less input (Plan 56).

Source code in src/quiverlab/core/algebra.py

def is_simply_connected(self, strong="auto", convex_budget=20000):
    """Three-valued simple-connectivity verdict: True only via decidable
    sufficient criteria (tree / no-bypass Le Meur / separation), False via a
    decidable witness (disconnected / oriented cycle / nontrivial pi1^ab), else
    None (inconclusive, honest per Adian-Rabin). Carries the R16
    strongly-simply-connected certificate (the P62 gate). Loud on
    presentation-less input (Plan 56)."""
    from quiverlab.invariants.coverings import is_simply_connected
    return is_simply_connected(self, strong=strong, convex_budget=convex_budget)

is_solvable_hh1

is_solvable_hh1(budget=None)

Is HH^1(A) a solvable Lie algebra? Any exact field (Plan 70).

Source code in src/quiverlab/core/algebra.py

def is_solvable_hh1(self, budget=None):
    """Is HH^1(A) a solvable Lie algebra? Any exact field (Plan 70)."""
    from quiverlab.invariants.hh1_lie import DEFAULT_MAXDIM, is_solvable_hh1
    return is_solvable_hh1(self, budget=DEFAULT_MAXDIM if budget is None else budget)

is_special_biserial

is_special_biserial()

True iff A is special biserial (ASS: <= 2 arrows in/out per vertex + the one-continuation condition).

Source code in src/quiverlab/core/algebra.py

def is_special_biserial(self):
    """True iff A is special biserial (ASS: <= 2 arrows in/out per vertex +
    the one-continuation condition)."""
    from quiverlab.invariants.recognizers import is_special_biserial
    return is_special_biserial(self)

is_string

is_string()

True iff A is a string algebra (special biserial + monomial ideal).

Source code in src/quiverlab/core/algebra.py

def is_string(self):
    """True iff A is a string algebra (special biserial + monomial ideal)."""
    from quiverlab.invariants.recognizers import is_string
    return is_string(self)

is_strongly_simply_connected

is_strongly_simply_connected(convex_budget=20000)

The R16 recognizer: separation for every full convex subcategory (Skowronski 1993). Three-valued (None on char/budget events), witness on failure. Triangular only (loud otherwise). The clean certificate P62 reads (Plan 56).

Source code in src/quiverlab/core/algebra.py

def is_strongly_simply_connected(self, convex_budget=20000):
    """The R16 recognizer: separation for every full convex subcategory
    (Skowronski 1993). Three-valued (None on char/budget events), witness on
    failure. Triangular only (loud otherwise). The clean certificate P62 reads
    (Plan 56)."""
    from quiverlab.invariants.coverings import is_strongly_simply_connected
    return is_strongly_simply_connected(self, convex_budget=convex_budget)

is_symmetric

is_symmetric()

Is the algebra symmetric — does it carry a nondegenerate trace form lambda(ab) = lambda(ba) (equivalently A ~= DA as bimodules)? Exact over every exact Domain via the trace-form certificate on the path-type basis (Plan 29; Skowronski–Yamagata). Loud refusal on a presentation-less algebra, like the other path-basis invariants.

Plan 29 replaced the former GF(p) shortcut is_frobenius and the engine's Nakayama automorphism == identity matrix, which was sufficient-not-necessary and returned a silent wrong False on multi-vertex symmetric Nakayama (Brauer star) algebras.

Source code in src/quiverlab/core/algebra.py

def is_symmetric(self):
    """Is the algebra symmetric — does it carry a nondegenerate trace form
    lambda(ab) = lambda(ba) (equivalently A ~= DA as bimodules)? Exact over
    every exact Domain via the trace-form certificate on the path-type basis
    (Plan 29; Skowronski–Yamagata). Loud refusal on a presentation-less
    algebra, like the other path-basis invariants.

    Plan 29 replaced the former GF(p) shortcut ``is_frobenius and the
    engine's Nakayama automorphism == identity matrix``, which was
    sufficient-not-necessary and returned a silent wrong False on
    multi-vertex symmetric Nakayama (Brauer star) algebras."""
    from quiverlab.invariants.frobenius import is_symmetric_generic
    return is_symmetric_generic(self)

is_tau_exceptional_sequence

is_tau_exceptional_sequence(seq)

True iff seq is a signed tau-exceptional sequence over this algebra (Plan 65 / R27): a reduction tower, or an ambient (inner, ..., outer) sequence recognized by the Jasso reduction recursion.

Source code in src/quiverlab/core/algebra.py

def is_tau_exceptional_sequence(self, seq):
    """True iff ``seq`` is a signed tau-exceptional sequence over this algebra
    (Plan 65 / R27): a reduction tower, or an ambient ``(inner, ..., outer)`` sequence
    recognized by the Jasso reduction recursion."""
    from quiverlab.tautilting.exceptional import is_tau_exceptional_sequence
    return is_tau_exceptional_sequence(self, seq)

is_tilted

is_tilted(budget_modules=256, budget_sections=4096) -> bool

True iff this algebra is tilted (Plan 60); the Boolean shorthand for bool(self.tilted_check(...)). An honest unknown verdict (rep-infinite non-hereditary / budget-tripped) returns False -- read tilted_check for the status when the distinction matters.

Source code in src/quiverlab/core/algebra.py

def is_tilted(self, budget_modules=256, budget_sections=4096) -> bool:
    """``True`` iff this algebra is tilted (Plan 60); the Boolean shorthand for
    ``bool(self.tilted_check(...))``. An honest ``unknown`` verdict (rep-infinite
    non-hereditary / budget-tripped) returns ``False`` -- read ``tilted_check`` for the
    status when the distinction matters."""
    return bool(self.tilted_check(budget_modules=budget_modules,
                                  budget_sections=budget_sections))

is_tilting_module

is_tilting_module(T, n=1)

A :class:~quiverlab.modules.tilting.TiltingReport for whether the module T is an n-tilting module over this algebra (Plan 44 / C7): pd <= n, Ext^i(T,T)=0 (1<=i<=n), and the Bongartz count criterion for n=1. The summand count inherits the decompose char caveat (char 0 or char > dim).

Source code in src/quiverlab/core/algebra.py

def is_tilting_module(self, T, n=1):
    """A :class:`~quiverlab.modules.tilting.TiltingReport` for whether the module
    ``T`` is an ``n``-tilting module over this algebra (Plan 44 / C7): pd <= n,
    Ext^i(T,T)=0 (1<=i<=n), and the Bongartz count criterion for n=1. The summand
    count inherits the ``decompose`` char caveat (char 0 or char > dim)."""
    from quiverlab.modules.tilting import is_tilting_module
    return is_tilting_module(T, n=n)

is_weakly_nonnegative

is_weakly_nonnegative(budget=3000000)

Exact weak-nonnegativity FormVerdict of the combinatorial Tits form, decided by the classified hypercritical list (primary) + a sound witness finder. A False is a FOUND witness d >= 0 with q(d) < 0; a True rests on the positive-semidefinite certificate or recorded list completeness; else honest None -- never a guessed True (Plan 62 / R19).

Source code in src/quiverlab/core/algebra.py

def is_weakly_nonnegative(self, budget=3_000_000):
    """Exact weak-nonnegativity FormVerdict of the combinatorial Tits form,
    decided by the classified hypercritical list (primary) + a sound witness
    finder. A False is a FOUND witness d >= 0 with q(d) < 0; a True rests on the
    positive-semidefinite certificate or recorded list completeness; else honest
    None -- never a guessed True (Plan 62 / R19)."""
    from quiverlab.invariants.tits import as_unit_form, is_weakly_nonnegative
    return is_weakly_nonnegative(as_unit_form(self), budget=budget)

is_weakly_positive

is_weakly_positive(budget=3000000)

Exact weak-positivity FormVerdict of the combinatorial Tits form (Ovsienko's box-6, branch-and-bound; positive-definite / isotropic-radical fast certificates). None only on budget, never a guessed True. A False carries the exact witness d >= 0 with q(d) <= 0 (Plan 62 / R19).

Source code in src/quiverlab/core/algebra.py

def is_weakly_positive(self, budget=3_000_000):
    """Exact weak-positivity FormVerdict of the combinatorial Tits form
    (Ovsienko's box-6, branch-and-bound; positive-definite / isotropic-radical
    fast certificates). None only on budget, never a guessed True. A False
    carries the exact witness d >= 0 with q(d) <= 0 (Plan 62 / R19)."""
    from quiverlab.invariants.tits import as_unit_form, is_weakly_positive
    return is_weakly_positive(as_unit_form(self), budget=budget)

is_weakly_shod

is_weakly_shod(budget=256)

True iff this algebra is weakly shod -- the lengths of irreducible-morphism paths from an injective to a projective are bounded (Coelho-Lanzilotta); the weakly_shod rung of :meth:recognizer_ladder. Raises a typed QuiverlabError (never a raw KeyError) when the ladder refuses; three-valued view on :meth:recognizer_ladder.

Source code in src/quiverlab/core/algebra.py

def is_weakly_shod(self, budget=256):
    """True iff this algebra is weakly shod -- the lengths of irreducible-morphism paths
    from an injective to a projective are bounded (Coelho-Lanzilotta); the ``weakly_shod``
    rung of :meth:`recognizer_ladder`. Raises a typed ``QuiverlabError`` (never a raw
    KeyError) when the ladder refuses; three-valued view on :meth:`recognizer_ladder`."""
    return self._recognizer_verdict("weakly_shod", budget)

is_weakly_symmetric

is_weakly_symmetric()

Is the algebra weakly symmetric — Frobenius with the identity Nakayama permutation (soc P_v = top P_v for every indecomposable projective)? Exact over every exact Domain (Plan 29). For self-injective Nakayama kZ_n/J^L this is n | (L - 1) (Skowronski–Yamagata, Frobenius Algebras I). Every symmetric algebra is weakly symmetric; the converse can fail.

Source code in src/quiverlab/core/algebra.py

def is_weakly_symmetric(self):
    """Is the algebra weakly symmetric — Frobenius with the identity Nakayama
    permutation (soc P_v = top P_v for every indecomposable projective)?
    Exact over every exact Domain (Plan 29). For self-injective Nakayama
    kZ_n/J^L this is n | (L - 1) (Skowronski–Yamagata, Frobenius Algebras I).
    Every symmetric algebra is weakly symmetric; the converse can fail."""
    from quiverlab.invariants.frobenius import is_weakly_symmetric_generic
    return is_weakly_symmetric_generic(self)

koszul_profile

koszul_profile(top=8)

The generalized-Koszulity profile (Plan 77): Plan 27's quadratic Koszul verdict together with Berger's N-Koszul certificate, Cassidy-Shelton K2 (through an explicit certified window), the Brenner-Butler-King (p,q)-almost-Koszul classifier, Herscovich's scoped multi-Koszul record, and the internal (path-length) generation degrees of Ext(k,k).

Source code in src/quiverlab/core/algebra.py

def koszul_profile(self, top=8):
    """The generalized-Koszulity profile (Plan 77): Plan 27's quadratic Koszul
    verdict together with Berger's N-Koszul certificate, Cassidy-Shelton K2
    (through an explicit certified window), the Brenner-Butler-King
    (p,q)-almost-Koszul classifier, Herscovich's scoped multi-Koszul record, and
    the internal (path-length) generation degrees of Ext(k,k)."""
    from quiverlab.modules.nkoszul import koszul_profile
    return koszul_profile(self, top)

left_part

left_part(budget=256)

The left part L_A = { M in ind A : pd L <= 1 for every predecessor L of M } (Plan 55) -- the left records of :meth:left_right_parts.

Source code in src/quiverlab/core/algebra.py

def left_part(self, budget=256):
    """The left part L_A = { M in ind A : pd L <= 1 for every predecessor L of M }
    (Plan 55) -- the ``left`` records of :meth:`left_right_parts`."""
    from quiverlab.modules.left_right import left_right_parts
    return left_right_parts(self, budget=budget).left

left_right_parts

left_right_parts(budget=256, budget_dim=64)

The left/right parts L_A, R_A of the module category, their intersection and the finite complement ind A \ (L_A u R_A), the Ext-injectives of add L_A (and dual Ext-projectives of add R_A), and the left/right support algebras A_lambda, A_rho (Plan 55 / R15, Assem-Coelho-Trepode). Returns a LeftRightAtlas; complete iff A is representation-finite and not self-injective, else a loud status (never a partial atlas). budget_dim caps the knitted per-module dimension (default 64): a rep-infinite input the fast certificate misses trips a loud status="budget" in bounded time rather than hanging -- raise it for a rep-finite algebra with larger indecomposables.

Source code in src/quiverlab/core/algebra.py

def left_right_parts(self, budget=256, budget_dim=64):
    """The left/right parts L_A, R_A of the module category, their intersection and
    the finite complement ind A \\ (L_A u R_A), the Ext-injectives of add L_A (and dual
    Ext-projectives of add R_A), and the left/right support algebras A_lambda, A_rho
    (Plan 55 / R15, Assem-Coelho-Trepode). Returns a LeftRightAtlas; complete iff A is
    representation-finite and not self-injective, else a loud status (never a partial
    atlas). ``budget_dim`` caps the knitted per-module dimension (default 64): a
    rep-infinite input the fast certificate misses trips a loud status="budget" in
    bounded time rather than hanging -- raise it for a rep-finite algebra with larger
    indecomposables."""
    from quiverlab.modules.left_right import left_right_parts
    return left_right_parts(self, budget=budget, budget_dim=budget_dim)

loewy_length

loewy_length()

Loewy length = nilpotency index of rad A (exact, any field) (spec §3.5).

Source code in src/quiverlab/core/algebra.py

def loewy_length(self):
    """Loewy length = nilpotency index of rad A (exact, any field) (spec §3.5)."""
    from quiverlab.invariants.scalar import loewy_length
    return loewy_length(self)

minimal_relation_counts

minimal_relation_counts()

{(src, tgt): count} of the minimal relations of I per ordered vertex pair (= dim_k e_tgt (I/(rad.I + I.rad)) e_src, the Tits-form r_ij). Loud on presentation-less input; empty for a hereditary algebra (Plan 56 / P62).

Source code in src/quiverlab/core/algebra.py

def minimal_relation_counts(self):
    """{(src, tgt): count} of the minimal relations of I per ordered vertex pair
    (= dim_k e_tgt (I/(rad.I + I.rad)) e_src, the Tits-form r_ij). Loud on
    presentation-less input; empty for a hereditary algebra (Plan 56 / P62)."""
    from quiverlab.invariants.coverings import minimal_relation_counts
    return minimal_relation_counts(self)

module

module(dimension_vector, arrow_action, side='right', name='M')

Build a module from a dimension vector + one exact matrix per arrow (Plan 05 Module.from_arrow_action). side="right" (default) reads the matrices as a right A-module (arrow a: s->t acting M_s -> M_t); side="left" builds a left A-module = right A^op-module, so the matrices are the opposite- quiver representation (Plan 24).

dimension_vector is a {vertex: dim} dict OR a vertex-ordered tuple/list of dimensions (one per vertex, in quiver.vertices order).

Source code in src/quiverlab/core/algebra.py

def module(self, dimension_vector, arrow_action, side="right", name="M"):
    """Build a module from a dimension vector + one exact matrix per arrow
    (Plan 05 `Module.from_arrow_action`). ``side="right"`` (default) reads the
    matrices as a right A-module (arrow a: s->t acting M_s -> M_t); ``side="left"``
    builds a left A-module = right A^op-module, so the matrices are the opposite-
    quiver representation (Plan 24).

    ``dimension_vector`` is a ``{vertex: dim}`` dict OR a vertex-ordered
    tuple/list of dimensions (one per vertex, in ``quiver.vertices`` order)."""
    from quiverlab.modules.module import Module
    if side == "right":
        dv = _normalize_dimension_vector(self, dimension_vector)
        return Module.from_arrow_action(self, dv, arrow_action, name=name)
    if side == "left":
        from quiverlab.modules.opposite import opposite_algebra
        op = opposite_algebra(self)
        dv = _normalize_dimension_vector(op, dimension_vector)
        m = Module.from_arrow_action(op, dv, arrow_action, name=name)
        return m.with_side("left")
    from quiverlab.errors import QuiverlabError
    raise QuiverlabError(f'side must be "right" or "left", got {side!r}')

nakayama_automorphism

nakayama_automorphism()

Nakayama automorphism nu as a matrix (columns = images) in the algebra's basis. GF(p): integer matrix via the engine (unit-adapted basis). Other exact Domains: Domain-element matrix on the path-type basis (Plan 19). Loud if not Frobenius.

Source code in src/quiverlab/core/algebra.py

def nakayama_automorphism(self):
    """Nakayama automorphism nu as a matrix (columns = images) in the
    algebra's basis. GF(p): integer matrix via the engine (unit-adapted
    basis). Other exact Domains: Domain-element matrix on the path-type
    basis (Plan 19). Loud if not Frobenius."""
    from quiverlab.fields.primefield import PrimeField
    if isinstance(self.domain, PrimeField):
        from quiverlab.engine.adapter import to_engine
        from quiverlab.engine.coxeter import nakayama_automorphism
        S, _ = nakayama_automorphism(to_engine(self.unit_adapted()), self.domain.p)
        return [[int(S[i, j]) for j in range(S.shape[1])] for i in range(S.shape[0])]
    from quiverlab.invariants.frobenius import nakayama_automorphism_generic
    return nakayama_automorphism_generic(self)

obstruction_map

obstruction_map(engine='auto')

The primary deformation obstruction alpha |-> [alpha,alpha] in HH^3 -- the targeted (2,2) CS Gerstenhaber self-bracket (Plan 78). Field-general; the unobstructed verdict + a basis-dependent witness. Returns a frozen Obstruction.

Source code in src/quiverlab/core/algebra.py

def obstruction_map(self, engine="auto"):
    """The primary deformation obstruction alpha |-> [alpha,alpha] in HH^3 -- the
    targeted (2,2) CS Gerstenhaber self-bracket (Plan 78). Field-general; the
    `unobstructed` verdict + a basis-dependent witness. Returns a frozen Obstruction."""
    from quiverlab.hochschild.deformations import obstruction_map
    return obstruction_map(self, engine=engine)

opposite

opposite()

The opposite algebra A^op (reversed quiver, transposed structure constants), as a first-class Algebra. Involutive: A.opposite().opposite() is A (Plan 23).

Source code in src/quiverlab/core/algebra.py

def opposite(self):
    """The opposite algebra A^op (reversed quiver, transposed structure
    constants), as a first-class Algebra. Involutive: A.opposite().opposite()
    is A (Plan 23)."""
    from quiverlab.modules.opposite import opposite_algebra
    return opposite_algebra(self)

orbit_dimension

orbit_dimension(M)

dim of the GL(d)-orbit of the module M in Rep(Q, d): dim O_M = sum_v d_v^2 - dim_k End_A(M) (Plan 49 / C8). Exact over every Domain.

Source code in src/quiverlab/core/algebra.py

def orbit_dimension(self, M):
    """dim of the GL(d)-orbit of the module M in Rep(Q, d):
    dim O_M = sum_v d_v^2 - dim_k End_A(M) (Plan 49 / C8). Exact over every
    Domain."""
    from quiverlab.invariants.geometry import orbit_dimension
    return orbit_dimension(M)

phi_dim

phi_dim(**kw)

The Igusa-Todorov phi-dimension phidim(A) = sup{ phi(M) } as an ALGEBRA invariant (Plan 53 / R23a): EXACT for representation-finite A (direct sum of all indecomposables via add-monotonicity), a certified LOWER bound when the AR knit caps, the exact 0 for self-injective A. A :class:~quiverlab.modules.homdims.PhiDim.

Source code in src/quiverlab/core/algebra.py

def phi_dim(self, **kw):
    """The Igusa-Todorov phi-dimension ``phidim(A) = sup{ phi(M) }`` as an ALGEBRA
    invariant (Plan 53 / R23a): EXACT for representation-finite ``A`` (direct sum of
    all indecomposables via add-monotonicity), a certified LOWER bound when the AR
    knit caps, the exact ``0`` for self-injective ``A``. A :class:`~quiverlab.modules.homdims.PhiDim`."""
    from quiverlab.modules.homdims import phi_dim
    return phi_dim(self, **kw)

phi_spectrum

phi_spectrum(**kw)

The phi-spectrum { phi(X) : X indecomposable } + its gaps (Plan 53 / R23b; Barrios-Mata-Rama). Rep-finite only; a partial spectrum claims no gaps. A :class:~quiverlab.modules.homdims.PhiSpectrum.

Source code in src/quiverlab/core/algebra.py

def phi_spectrum(self, **kw):
    """The phi-spectrum ``{ phi(X) : X indecomposable }`` + its gaps (Plan 53 / R23b;
    Barrios-Mata-Rama). Rep-finite only; a partial spectrum claims no gaps. A
    :class:`~quiverlab.modules.homdims.PhiSpectrum`."""
    from quiverlab.modules.homdims import phi_spectrum
    return phi_spectrum(self, **kw)

picture_group

picture_group(budget=512)

The picture-group presentation pi_1(|W(A)|) as DATA (Plan 66 / R29; Igusa-Todorov-Weyman arXiv:1609.02636; Hanson-Igusa): generators = the bricks, relations = the rank-2 wides (typed commutation / atom via Ext^1), and the abelianization by exact Smith normal form. Certified complete iff A is tau-tilting-finite.

Source code in src/quiverlab/core/algebra.py

def picture_group(self, budget=512):
    """The picture-group presentation ``pi_1(|W(A)|)`` as DATA (Plan 66 / R29;
    Igusa-Todorov-Weyman arXiv:1609.02636; Hanson-Igusa): generators = the bricks,
    relations = the rank-2 wides (typed commutation / atom via ``Ext^1``), and the
    abelianization by exact Smith normal form. Certified complete iff ``A`` is
    tau-tilting-finite."""
    from quiverlab.tautilting.cluster_morphism import picture_group
    return picture_group(self, budget=budget)

positive_roots

positive_roots()

Positive roots of the Tits form (= dimension vectors of the indecomposables, Gabriel) for a hereditary Dynkin algebra; loud on affine/wild/non-hereditary input (Plan 38 / C2).

Source code in src/quiverlab/core/algebra.py

def positive_roots(self):
    """Positive roots of the Tits form (= dimension vectors of the
    indecomposables, Gabriel) for a hereditary Dynkin algebra; loud on
    affine/wild/non-hereditary input (Plan 38 / C2)."""
    from quiverlab.invariants.roots import positive_roots
    return positive_roots(self)

presented_form

presented_form()

A genuine kQ/I presentation of the basic algebra, recovered from the structure constants and certified per instance (dim + multiplicativity), so End(M) / End(T) read back as kQ/I (Plan 44 / C7). Loud refusal off char-scope or on a non-split division-algebra block.

Source code in src/quiverlab/core/algebra.py

def presented_form(self):
    """A genuine ``kQ/I`` presentation of the basic algebra, recovered from the
    structure constants and certified per instance (dim + multiplicativity), so
    ``End(M)`` / ``End(T)`` read back as ``kQ/I`` (Plan 44 / C7). Loud refusal off
    char-scope or on a non-split division-algebra block."""
    from quiverlab.core.basic import presented_form
    return presented_form(self)

primitive_idempotents

primitive_idempotents()

A complete set of orthogonal primitive idempotents of this algebra (coordinate vectors summing to the unit) via the exact Wedderburn/trace-form route (Plan 44 / C7). Char 0 or char > dim only, else a loud QuiverlabError.

Source code in src/quiverlab/core/algebra.py

def primitive_idempotents(self):
    """A complete set of orthogonal primitive idempotents of this algebra (coordinate
    vectors summing to the unit) via the exact Wedderburn/trace-form route (Plan 44 /
    C7). Char 0 or char > dim only, else a loud QuiverlabError."""
    from quiverlab.core.basic import primitive_idempotents
    return primitive_idempotents(self)

projective

projective(v, side='right')

The indecomposable projective P_v: right e_v A (default) or, with side="left", the left projective A e_v (Plan 24).

Source code in src/quiverlab/core/algebra.py

def projective(self, v, side="right"):
    """The indecomposable projective P_v: right ``e_v A`` (default) or, with
    ``side="left"``, the left projective ``A e_v`` (Plan 24)."""
    return self._sided_builder("projective", v, side)

psi_dim

psi_dim(**kw)

The Igusa-Todorov psi-dimension psidim(A) = sup{ psi(M) } as an ALGEBRA invariant (Plan 53 / R23a); same rep-finite/honest-degrade contract as :meth:phi_dim. A :class:~quiverlab.modules.homdims.PsiDim.

Source code in src/quiverlab/core/algebra.py

def psi_dim(self, **kw):
    """The Igusa-Todorov psi-dimension ``psidim(A) = sup{ psi(M) }`` as an ALGEBRA
    invariant (Plan 53 / R23a); same rep-finite/honest-degrade contract as
    :meth:`phi_dim`. A :class:`~quiverlab.modules.homdims.PsiDim`."""
    from quiverlab.modules.homdims import psi_dim
    return psi_dim(self, **kw)

quotient_by_idempotent

quotient_by_idempotent(vertices)

The quotient A / A e_S A at S = vertices (Plan 47).

Source code in src/quiverlab/core/algebra.py

def quotient_by_idempotent(self, vertices):
    """The quotient ``A / A e_S A`` at ``S = vertices`` (Plan 47)."""
    from quiverlab.modules.recollement import Recollement
    return Recollement(self, vertices).quotient

radical_filtration

radical_filtration(budget_modules=256, budget_dim=4096)

The radical filtration of mod A (Plan 57 / R37): exact dim rad^n(X, Y) layer dimensions on the knitted indecomposables, the nilpotency index of rad(mod A), and the rad^inf = 0 <=> representation-finite certificate (Auslander). Returns a :class:~quiverlab.modules.radical.RadicalFiltration; certified iff the knit closes (rep-finite), else an honest window/refusal with no verdict.

Source code in src/quiverlab/core/algebra.py

def radical_filtration(self, budget_modules=256, budget_dim=4096):
    """The radical filtration of ``mod A`` (Plan 57 / R37): exact
    ``dim rad^n(X, Y)`` layer dimensions on the knitted indecomposables, the
    nilpotency index of ``rad(mod A)``, and the ``rad^inf = 0 <=>
    representation-finite`` certificate (Auslander). Returns a
    :class:`~quiverlab.modules.radical.RadicalFiltration`; certified iff the knit
    closes (rep-finite), else an honest window/refusal with no verdict."""
    from quiverlab.modules.radical import radical_filtration
    return radical_filtration(self, budget_modules=budget_modules,
                              budget_dim=budget_dim)

recognizer_ladder

recognizer_ladder(budget=256)

Classify this algebra against the Assem-school recognizer ladder -- quasi-tilted / shod / weakly-shod / laura / ada (Plan 61 / R18) -- off ONE :meth:left_right_parts atlas + :meth:global_dimension (+ one AR knit for the weakly-shod sweep). Returns a :class:~quiverlab.modules.recognizers_ladder.RecognizerLadder with the five witnessed/certified rungs, the finite laura complement, and -- for ada algebras over an algebraically closed field -- the ACLV-Theorem-B simple-connectedness verdict off HH^1. Complete iff representation-finite and not self-injective, else a loud status (never a partial ladder).

Source code in src/quiverlab/core/algebra.py

def recognizer_ladder(self, budget=256):
    """Classify this algebra against the Assem-school recognizer ladder --
    quasi-tilted / shod / weakly-shod / laura / ada (Plan 61 / R18) -- off ONE
    :meth:`left_right_parts` atlas + :meth:`global_dimension` (+ one AR knit for the
    weakly-shod sweep). Returns a :class:`~quiverlab.modules.recognizers_ladder.RecognizerLadder`
    with the five witnessed/certified rungs, the finite laura complement, and -- for ada
    algebras over an algebraically closed field -- the ACLV-Theorem-B simple-connectedness
    verdict off ``HH^1``. Complete iff representation-finite and not self-injective, else a
    loud status (never a partial ladder)."""
    from quiverlab.modules.recognizers_ladder import recognizer_ladder
    return recognizer_ladder(self, budget=budget)

recollement

recollement(vertices)

The recollement (mod A/AeA, mod A, mod eAe) at e = sum_{v in vertices} e_v (Plan 47): a :class:~quiverlab.modules.recollement.Recollement.

Source code in src/quiverlab/core/algebra.py

def recollement(self, vertices):
    """The recollement ``(mod A/AeA, mod A, mod eAe)`` at ``e = sum_{v in vertices}
    e_v`` (Plan 47): a :class:`~quiverlab.modules.recollement.Recollement`."""
    from quiverlab.modules.recollement import Recollement
    return Recollement(self, vertices)

relative_homology

relative_homology(new_arrows, top)

HH_*(A|B) (B = A minus new_arrows) via the CLMS normalized relative bar complex (Plan 73 / R7); finite when A/B is tensor-nilpotent (Cor. 2.4). Returns an HHTable.

Source code in src/quiverlab/core/algebra.py

def relative_homology(self, new_arrows, top):
    """``HH_*(A|B)`` (``B`` = ``A`` minus ``new_arrows``) via the CLMS normalized
    relative bar complex (Plan 73 / R7); finite when ``A/B`` is tensor-nilpotent
    (Cor. 2.4). Returns an ``HHTable``."""
    from quiverlab.families.extension import arrow_removal_subalgebra
    from quiverlab.hochschild.jacobi_zariski import relative_homology
    return relative_homology(arrow_removal_subalgebra(self, new_arrows), top)

right_part

right_part(budget=256)

The right part R_A (successors, id <= 1) -- the right records of :meth:left_right_parts (Plan 55).

Source code in src/quiverlab/core/algebra.py

def right_part(self, budget=256):
    """The right part R_A (successors, id <= 1) -- the ``right`` records of
    :meth:`left_right_parts` (Plan 55)."""
    from quiverlab.modules.left_right import left_right_parts
    return left_right_parts(self, budget=budget).right

rigidity_codim

rigidity_codim(M)

dim Ext^1_A(M, M): the codimension of the orbit closure in Rep(Q, d) on HEREDITARY A (Voigt), an UPPER BOUND on general kQ/I (Plan 49 / C8).

Source code in src/quiverlab/core/algebra.py

def rigidity_codim(self, M):
    """dim Ext^1_A(M, M): the codimension of the orbit closure in Rep(Q, d)
    on HEREDITARY A (Voigt), an UPPER BOUND on general kQ/I (Plan 49 / C8)."""
    from quiverlab.invariants.geometry import rigidity_codim
    return rigidity_codim(M)

ringel_dual

ringel_dual(order=None)

The Ringel dual R(A) = End_A(T)^op, presented as kQ/I (char 0 / char > dim) or loud-degraded to structure-constant form (Plan 47).

Source code in src/quiverlab/core/algebra.py

def ringel_dual(self, order=None):
    """The Ringel dual ``R(A) = End_A(T)^op``, presented as ``kQ/I`` (char 0 / char >
    dim) or loud-degraded to structure-constant form (Plan 47)."""
    from quiverlab.modules.quasihereditary import ringel_dual
    return ringel_dual(self, order)

separation_condition

separation_condition()

The separation condition at every vertex a: the distinct indecomposable summands of rad P_a have supports in distinct connected components of Q_a (Q minus a and its transitive predecessor closure). Triangular only (loud otherwise); a decompose char-caveat is caught as an undecided verdict (Plan 56 / R16).

Source code in src/quiverlab/core/algebra.py

def separation_condition(self):
    """The separation condition at every vertex a: the distinct indecomposable
    summands of rad P_a have supports in distinct connected components of Q_a
    (Q minus a and its transitive predecessor closure). Triangular only (loud
    otherwise); a decompose char-caveat is caught as an undecided verdict
    (Plan 56 / R16)."""
    from quiverlab.invariants.coverings import separation_condition
    return separation_condition(self)

silting_exploration

silting_exploration(radius=3, budget=64)

A bounded-radius exploration of the silting quiver from the regular object (Plan 67 / AI Thm 1.2 -- NO general BFS): loud status, certified complete only for local (:class:~quiverlab.derived.silting.SiltingExploration).

Source code in src/quiverlab/core/algebra.py

def silting_exploration(self, radius=3, budget=64):
    """A bounded-radius exploration of the silting quiver from the regular object
    (Plan 67 / AI Thm 1.2 -- NO general BFS): loud ``status``, certified complete only
    for local (:class:`~quiverlab.derived.silting.SiltingExploration`)."""
    from quiverlab.derived.silting import bounded_silting_exploration
    return bounded_silting_exploration(self, radius=radius, budget=budget)

silting_report

silting_report()

The silting-object verdict for the regular object A = (+)_v P_v in K^b(proj A) (Plan 67 / Aihara-Iyama): presilting on the exact positive window + three-valued generation (:class:~quiverlab.derived.silting.SiltingReport).

Source code in src/quiverlab/core/algebra.py

def silting_report(self):
    """The silting-object verdict for the regular object ``A = (+)_v P_v`` in
    ``K^b(proj A)`` (Plan 67 / Aihara-Iyama): presilting on the exact positive window
    + three-valued generation (:class:`~quiverlab.derived.silting.SiltingReport`)."""
    from quiverlab.derived.silting import is_silting_object
    from quiverlab.modules.complexes import ChainComplex
    return is_silting_object([ChainComplex.stalk(self.projective(v), 0)
                              for v in self.quiver.vertices])

simple

simple(v, side='right')

The simple S_v (spec §3.6). side="left" for the left A-module (Plan 24).

Source code in src/quiverlab/core/algebra.py

def simple(self, v, side="right"):
    """The simple S_v (spec §3.6). ``side="left"`` for the left A-module (Plan 24)."""
    return self._sided_builder("simple", v, side)

skew_group

skew_group(action)

The skew group algebra A rtimes G (smash product A # kG) for an explicit finite GroupAction acting by algebra automorphisms; a first-class structure-constant Algebra of dimension |G|*dim A (Plan 74). Characteristic-agnostic; the Stefan HH decomposition (quiverlab.hochschild.skew_group.stefan_decomposition) needs char k does not divide |G|.

Source code in src/quiverlab/core/algebra.py

def skew_group(self, action):
    """The skew group algebra ``A rtimes G`` (smash product ``A # kG``) for an
    explicit finite ``GroupAction`` acting by algebra automorphisms; a
    first-class structure-constant Algebra of dimension ``|G|*dim A`` (Plan 74).
    Characteristic-agnostic; the Stefan HH decomposition
    (``quiverlab.hochschild.skew_group.stefan_decomposition``) needs
    ``char k does not divide |G|``."""
    from quiverlab.families.skew_group import skew_group_algebra
    return skew_group_algebra(self, action)

split_extension_cohomology

split_extension_cohomology(top, M=None, max_cells=4000000)

The split-extension (trivial-extension) Hochschild-cohomology LES, assembling HH^•(T(A)) from the flanks HH^•(L, D(A)) / HH^•(L, A) and the snake connecting map, cross-checked against the direct HH^•(T(A)) (Plan 72 / R5, CMRS math/0102194). Returns a SplitExtReport.

Source code in src/quiverlab/core/algebra.py

def split_extension_cohomology(self, top, M=None, max_cells=4_000_000):
    """The split-extension (trivial-extension) Hochschild-cohomology LES,
    assembling ``HH^•(T(A))`` from the flanks ``HH^•(L, D(A))`` / ``HH^•(L, A)``
    and the snake connecting map, cross-checked against the direct ``HH^•(T(A))``
    (Plan 72 / R5, CMRS ``math/0102194``). Returns a ``SplitExtReport``."""
    from quiverlab.hochschild.split_extension import split_extension_cohomology
    return split_extension_cohomology(self, top, M=M, max_cells=max_cells)

split_extension_homology

split_extension_homology(top, M=None, max_cells=4000000)

The split-extension Hochschild-HOMOLOGY twin (the dual SES 0 → M → L → A → 0 in HH_•(L, −)). Returns a SplitExtReport.

Source code in src/quiverlab/core/algebra.py

def split_extension_homology(self, top, M=None, max_cells=4_000_000):
    """The split-extension Hochschild-HOMOLOGY twin (the dual SES
    ``0 → M → L → A → 0`` in ``HH_•(L, −)``). Returns a ``SplitExtReport``."""
    from quiverlab.hochschild.split_extension import split_extension_homology
    return split_extension_homology(self, top, M=M, max_cells=max_cells)

standard_modules

standard_modules(order=None)

The standard modules Delta(i) for the given vertex order (dict vertex -> Delta(i); order=None = natural order) (Plan 47).

Source code in src/quiverlab/core/algebra.py

def standard_modules(self, order=None):
    """The standard modules ``Delta(i)`` for the given vertex ``order`` (dict
    vertex -> Delta(i); ``order=None`` = natural order) (Plan 47)."""
    from quiverlab.modules.quasihereditary import standard_modules
    return standard_modules(self, order)

support_algebras

support_algebras(budget=256)

The left/right support algebras (A_lambda, A_rho) as presented induced-convex- subquiver Algebras (Plan 55) -- (left_support, right_support) of :meth:left_right_parts.

Source code in src/quiverlab/core/algebra.py

def support_algebras(self, budget=256):
    """The left/right support algebras (A_lambda, A_rho) as presented induced-convex-
    subquiver Algebras (Plan 55) -- ``(left_support, right_support)`` of
    :meth:`left_right_parts`."""
    from quiverlab.modules.left_right import left_right_parts
    atlas = left_right_parts(self, budget=budget)
    return atlas.left_support, atlas.right_support

tame_wild_certificate

tame_wild_certificate(convex_budget=20000, search_budget=3000000)

The Tits-form representation-type certificate: rep-finite / tame / wild gated on the P56 strong-simple-connectivity certificate over a characteristic-0 field (Bongartz 1984; Brustle-de la Pena-Skowronski 2011). The form is always computed; off scope the verdict is None (P56's None propagates, never a fabricated tame/wild) (Plan 62 / R19).

Source code in src/quiverlab/core/algebra.py

def tame_wild_certificate(self, convex_budget=20000, search_budget=3_000_000):
    """The Tits-form representation-type certificate: rep-finite / tame / wild
    gated on the P56 strong-simple-connectivity certificate over a
    characteristic-0 field (Bongartz 1984; Brustle-de la Pena-Skowronski 2011).
    The form is always computed; off scope the verdict is None (P56's None
    propagates, never a fabricated tame/wild) (Plan 62 / R19)."""
    from quiverlab.invariants.tits import tame_wild_certificate
    return tame_wild_certificate(self, convex_budget=convex_budget,
                                 search_budget=search_budget)

tate_hochschild

tate_hochschild(top, engine='auto', max_cells=4000000)

Tate-Hochschild (singular Hochschild) cohomology HHhat^m for every m in [-top, top] -- negative degrees included -- via a complete resolution of A over A^e. Above the Gorenstein dimension of A^e it agrees with ordinary HH^*; degree 0 does NOT (HHhat^0 is the stable centre, a quotient of Z(A) = HH^0). engine: 'auto', 'native' (the GF(p) splice, self-injective, knows every degree), 'duality' (symmetric, any Domain, degrees |m| >= 1), 'positive' (the threshold alone). A Gorenstein but non-self-injective algebra is a loud DEFERRED refusal.

Source code in src/quiverlab/core/algebra.py

def tate_hochschild(self, top, engine="auto", max_cells=4_000_000):
    """Tate-Hochschild (singular Hochschild) cohomology HHhat^m for every
    m in [-top, top] -- negative degrees included -- via a complete
    resolution of A over A^e. Above the Gorenstein dimension of A^e it
    agrees with ordinary HH^*; degree 0 does NOT (HHhat^0 is the stable
    centre, a quotient of Z(A) = HH^0). engine: 'auto', 'native' (the
    GF(p) splice, self-injective, knows every degree), 'duality'
    (symmetric, any Domain, degrees |m| >= 1), 'positive' (the threshold
    alone). A Gorenstein but non-self-injective algebra is a loud
    DEFERRED refusal."""
    from quiverlab.hochschild.tate import tate_hochschild
    return tate_hochschild(self, top, engine=engine, max_cells=max_cells)

tau_cluster_category

tau_cluster_category(budget=512)

The tau-cluster morphism category W(A) (Plan 66 / R29; Buan-Marsh IMRN 2021 + Hanson-Igusa Comm. Alg. 2021): objects = the tau-perpendicular wide subcategories (object_count == wide_subcategories(A).size), morphisms = support tau-rigid pairs of the source graded by rank, the Hanson-Igusa classifying-space cube-complex face_vector (f_0 = #wide, f_k = #(rank-k morphisms)) + Euler characteristic + the g-fan sphere g_fan_face_vector, and the theorem-anchored K(pi,1) verdict (Nakayama / hereditary Dynkin). Certified complete iff A is tau-tilting-finite.

Source code in src/quiverlab/core/algebra.py

def tau_cluster_category(self, budget=512):
    """The tau-cluster morphism category ``W(A)`` (Plan 66 / R29; Buan-Marsh IMRN 2021 +
    Hanson-Igusa Comm. Alg. 2021): objects = the tau-perpendicular wide subcategories
    (``object_count == wide_subcategories(A).size``), morphisms = support tau-rigid pairs
    of the source graded by rank, the Hanson-Igusa classifying-space cube-complex
    ``face_vector`` (``f_0 = #wide``, ``f_k = #(rank-k morphisms)``) + Euler characteristic
    + the ``g``-fan sphere ``g_fan_face_vector``, and the theorem-anchored ``K(pi,1)``
    verdict (Nakayama / hereditary Dynkin). Certified complete iff ``A`` is
    tau-tilting-finite."""
    from quiverlab.tautilting.cluster_morphism import tau_cluster_category
    return tau_cluster_category(self, budget=budget)

tau_exceptional_objects

tau_exceptional_objects(budget=512)

The length-1 signed tau-exceptional objects (Plan 65 / R27): the indecomposable tau-rigid modules (sign +1) + one shifted projective P_v[1] per vertex (sign -1). tau-tilting-finite scope; loud refusal otherwise. A list of :class:~quiverlab.tautilting.exceptional.TauExcObject.

Source code in src/quiverlab/core/algebra.py

def tau_exceptional_objects(self, budget=512):
    """The length-1 signed tau-exceptional objects (Plan 65 / R27): the indecomposable
    tau-rigid modules (sign +1) + one shifted projective ``P_v[1]`` per vertex (sign -1).
    tau-tilting-finite scope; loud refusal otherwise. A list of
    :class:`~quiverlab.tautilting.exceptional.TauExcObject`."""
    from quiverlab.tautilting.exceptional import tau_exceptional_objects
    return tau_exceptional_objects(self, budget=budget)

tau_exceptional_sequences

tau_exceptional_sequences(budget=4096, want_sequences=True)

The complete signed tau-exceptional sequences of this tau-tilting-finite algebra (Plan 65 / R27; Buan-Marsh): the ordered-support-tau-tilt bijection count signed_count = n! * #sTt plus the materialised reduction towers (the H1 cross-check). Loud refusal off a complete exchange graph (M1). Returns a :class:~quiverlab.tautilting.exceptional.TauExcReport.

Source code in src/quiverlab/core/algebra.py

def tau_exceptional_sequences(self, budget=4096, want_sequences=True):
    """The complete signed tau-exceptional sequences of this **tau-tilting-finite**
    algebra (Plan 65 / R27; Buan-Marsh): the ordered-support-tau-tilt bijection count
    ``signed_count = n! * #sTt`` plus the materialised reduction towers (the H1
    cross-check). Loud refusal off a complete exchange graph (M1). Returns a
    :class:`~quiverlab.tautilting.exceptional.TauExcReport`."""
    from quiverlab.tautilting.exceptional import tau_exceptional_sequences
    return tau_exceptional_sequences(self, budget=budget, want_sequences=want_sequences)

tikz

tikz()

TikZ source for the quiver, sharing draw()'s exact layout coordinates (spec §3.7). Paste into a LaTeX document.

Source code in src/quiverlab/core/algebra.py

def tikz(self):
    """TikZ source for the quiver, sharing draw()'s exact layout coordinates
    (spec §3.7). Paste into a LaTeX document."""
    if self.quiver is None:
        from quiverlab.errors import QuiverlabError
        raise QuiverlabError(
            "this Algebra has no quiver to render as TikZ",
            hint="build it via Quiver.algebra(...) rather than from_structure_constants")
    from quiverlab.viz.tikz import tikz_quiver
    return tikz_quiver(self.quiver, self.relations or [])

tilted_check

tilted_check(budget_modules=256, budget_sections=4096)

A :class:~quiverlab.modules.tilted.TiltedReport deciding whether this algebra is tilted -- A = End_H(T) for a hereditary H and a tilting H-module T (Plan 60 / R17) -- by the Liu-Skowronski faithful-section criterion on the AR quiver, certified by Ringel's slice theorem. Theorem gates (hereditary => tilted; non-semisimple self-injective => not; gl.dim > 2 => not) then a rep-finite exhaustive search; two budgets: the knit cap budget_modules and the transversal cap budget_sections (a product of orbit sizes). Char 0 / char > dim.

Source code in src/quiverlab/core/algebra.py

def tilted_check(self, budget_modules=256, budget_sections=4096):
    """A :class:`~quiverlab.modules.tilted.TiltedReport` deciding whether this algebra
    is tilted -- ``A = End_H(T)`` for a hereditary ``H`` and a tilting ``H``-module
    ``T`` (Plan 60 / R17) -- by the Liu-Skowronski faithful-section criterion on the
    AR quiver, certified by Ringel's slice theorem. Theorem gates (hereditary =>
    tilted; non-semisimple self-injective => not; gl.dim > 2 => not) then a rep-finite
    exhaustive search; two budgets: the knit cap ``budget_modules`` and the transversal
    cap ``budget_sections`` (a product of orbit sizes). Char 0 / char > dim."""
    from quiverlab.modules.tilted import tilted_check
    return tilted_check(self, budget_modules=budget_modules,
                        budget_sections=budget_sections)

tits_form

tits_form(d)

Tits quadratic form q(d) = of the Euler form (Plan 38 / C2).

Source code in src/quiverlab/core/algebra.py

def tits_form(self, d):
    """Tits quadratic form q(d) = <d, d> of the Euler form (Plan 38 / C2)."""
    from quiverlab.invariants.forms import tits_form
    return tits_form(self, d)

tits_form_combinatorial

tits_form_combinatorial(d)

The COMBINATORIAL Tits form q_A(d) = sum d_i^2 - sum_{arrows i->j} d_i d_j + sum_{(i,j)} r_ij d_i d_j, r_ij = minimal_relation_counts (P56); it truncates the Euler form at Ext^2 and is defined for every admissible presentation (they coincide iff gl.dim <= 2). Distinct from tits_form (Plan 38's homological Euler form). Field-free exact int (Plan 62 / R19).

Source code in src/quiverlab/core/algebra.py

def tits_form_combinatorial(self, d):
    """The COMBINATORIAL Tits form q_A(d) = sum d_i^2 - sum_{arrows i->j} d_i
    d_j + sum_{(i,j)} r_ij d_i d_j, r_ij = minimal_relation_counts (P56); it
    truncates the Euler form at Ext^2 and is defined for every admissible
    presentation (they coincide iff gl.dim <= 2). Distinct from tits_form
    (Plan 38's homological Euler form). Field-free exact int (Plan 62 / R19)."""
    from quiverlab.invariants.tits import tits_form_combinatorial
    return tits_form_combinatorial(self, d)

tor

tor(M, N, n)

dim Tor_n^A(M, N) for a RIGHT A-module M and a LEFT A-module N (Plan 29).

The homological sibling of ext: H_n(P_ (x)A N) with P the minimal projective resolution of the right module M. Certified against ext by the duality dim Tor_n(M, N) = dim Ext^n(M, DN) (D side-aware, Plan 24).

Source code in src/quiverlab/core/algebra.py

def tor(self, M, N, n):
    """dim Tor_n^A(M, N) for a RIGHT A-module M and a LEFT A-module N (Plan 29).

    The homological sibling of ``ext``: H_n(P_* (x)_A N) with P_* the minimal
    projective resolution of the right module M. Certified against ``ext`` by the
    duality dim Tor_n(M, N) = dim Ext^n(M, DN) (D side-aware, Plan 24)."""
    from quiverlab.modules.tor import tor
    return tor(self, M, N, n)

torsion_lattice

torsion_lattice(budget=512)

The finite lattice tors A (Plan 64 / R26, DIRRT): order, join/meet (is_lattice self-cert), join-/meet-irreducibles, canonical join representations, and the SD/modular/distributive flags -- extracted from the P45 oriented exchange graph. Certified complete iff A is tau-tilting-finite (else an honest is_complete=False value, no partial-lattice lie).

Source code in src/quiverlab/core/algebra.py

def torsion_lattice(self, budget=512):
    """The finite lattice ``tors A`` (Plan 64 / R26, DIRRT): order, join/meet
    (``is_lattice`` self-cert), join-/meet-irreducibles, canonical join representations,
    and the SD/modular/distributive flags -- extracted from the P45 oriented exchange
    graph. Certified complete iff ``A`` is tau-tilting-finite (else an honest
    ``is_complete=False`` value, no partial-lattice lie)."""
    from quiverlab.tautilting.congruence import torsion_lattice
    return torsion_lattice(self, budget=budget)

unit_adapted

unit_adapted()

Return an isomorphic copy whose basis vector 0 is 1_A (spec §5, component 4).

Source code in src/quiverlab/core/algebra.py

def unit_adapted(self):
    """Return an isomorphic copy whose basis vector 0 is 1_A (spec §5, component 4)."""
    if self.is_unit_adapted:
        return self
    dom = self.domain
    m = self.dim
    j = next(i for i, c in enumerate(self.unit) if not dom.is_zero(c))
    P = self._unit_adapting_change()
    out = self.change_of_basis(P)
    labels = None
    if self.basis_labels is not None:
        labels = list(self.basis_labels)
        old0 = labels[j]
        labels[j] = old0 if j == 0 else labels[0]
        labels[0] = "1"
        if j == 0:
            labels[0] = "1"
    out.basis_labels = labels
    out.is_unit_adapted = True
    return out

wall_chamber_structure

wall_chamber_structure(budget_pairs=512)

The wall-and-chamber structure of A via bricks (Plan 63 / R25): the chambers (g-vector cones of the support tau-tilting pairs), the walls D(B) (one per brick, each an EXACT rational inequality system over the submodule dim-vectors -- BST 2019 / King 1994), the chamber<->wall adjacency, the four counts, and a 2D/3D drawing for rank <= 3. Certified COMPLETE iff A is brick-finite <=> tau-tilting-finite (DIJ); otherwise a BOUNDED region with honest truncation and no count. Char 0 / char > dim (QQ default; loud off scope).

Source code in src/quiverlab/core/algebra.py

def wall_chamber_structure(self, budget_pairs=512):
    """The wall-and-chamber structure of ``A`` via bricks (Plan 63 / R25): the chambers
    (g-vector cones of the support tau-tilting pairs), the walls ``D(B)`` (one per brick,
    each an EXACT rational inequality system over the submodule dim-vectors -- BST 2019 /
    King 1994), the chamber<->wall adjacency, the four counts, and a 2D/3D drawing for
    rank <= 3. Certified COMPLETE iff ``A`` is brick-finite <=> tau-tilting-finite (DIJ);
    otherwise a BOUNDED region with honest truncation and no count. Char 0 / char > dim
    (QQ default; loud off scope)."""
    from quiverlab.tautilting.wallchamber import wall_chamber_structure
    return wall_chamber_structure(self, budget=budget_pairs)

wide_subcategories

wide_subcategories(budget=512)

The wide-subcategory poset (Plan 64 / R26, Enomoto 2201.00595): computed from tors A via the core label order AND the kappa order (asserted to coincide), isomorphic to (wide A, subseteq). Certified complete iff A is tau-tilting-finite.

Source code in src/quiverlab/core/algebra.py

def wide_subcategories(self, budget=512):
    """The wide-subcategory poset (Plan 64 / R26, Enomoto 2201.00595): computed from
    ``tors A`` via the core label order AND the kappa order (asserted to coincide),
    isomorphic to ``(wide A, subseteq)``. Certified complete iff ``A`` is
    tau-tilting-finite."""
    from quiverlab.tautilting.congruence import wide_subcategories
    return wide_subcategories(self, budget=budget)