auslander
Computational representation theory of finite-dimensional bound quiver algebras.
Scope: finite-dimensional basic algebras kQ/I over a checked prime field, where I is a general admissible ideal, and finite-dimensional right modules. Correct before general.
Install
Install the Rust crate from crates.io:
Install the Python package from PyPI:
Complete catalog queries
Version 0.9 adds reusable Ext tables and complete fixed-dimension module searches over certified indecomposable catalogs. Catalogs cover Nakayama algebras, zero-ideal Dynkin path algebras, and gentle algebras whose underlying undirected quiver is a tree.
Build a field-bound algebra, choose its complete catalog, and cache the ordered Ext dimensions:
=
=
=
=
=
=
For catalog entries X_i, the atlas stores
E_k[i,j] = dim Ext^k(X_i,X_j). A multiplicity vector m describes
⊕ m_i X_i. The query enumerates every vector satisfying
Σ m_i dim X_i = d, or returns a typed Cut with its exact retained prefix.
Cached scores use m^T E_k n. Direct-sum materialization requires no
isomorphism search.
A portable atlas artifact records its certificate, field, catalog order, dimension vector, degree bound, limits, status, and rows. Replay rebuilds the catalog, repeats the enumeration, and checks every Ext cell through the generic Ext path. It rejects omitted and duplicate rows. A replayed Cut remains a Cut. Replay shares library algorithms; the GAP/QPA fixtures provide separate comparisons on the tested inputs.
Start with the executed catalog workflow and its teaching notebook. The artifact contract explains replay and limits. The benchmark measures setup, queries, materialization, and verification. Existing Python users should read the v0.9 migration guide.
General algebras retain the finite raw-census workflow introduced in v0.8. The commutative-square study records a finite self-Ext locus, including a degree-two obstruction missed by a degree-one check. See the theorem artifact guide, compiled-family measurements, and derived workbench contract.
First result
Named constructors build common algebras. This example computes the dimension and Cartan matrix of the three-arrow Kronecker algebra over F_5:
use kronecker;
use PrimeField;
let algebra = kronecker;
assert_eq!;
assert_eq!;
A relation is a k-combination of paths of length at least 2 that all share one
source and one target. ab - cd is a relation, and so is the inhomogeneous
ab - cde. A monomial ideal is the case where every relation has one term.
Non-uniform input is rejected, not decomposed.
Every algebra comes from one pipeline. Completion turns the relations into the reduced Groebner basis of the ideal and emits a serializable certificate. The verifier reads that certificate back from bytes and rechecks the whole claim.
The verifier checks both ideal inclusions: each basis element expands to a
two-sided combination of the input relations, and each input relation reduces to
zero over the basis. It re-enumerates every overlap and inclusion ambiguity
itself, and rejects a missing entry and an extra one. Every reduction
trace replays to zero in strict order descent. The verifier rebuilds the
normal-word automaton from the leading words with its own construction and
requires the certificate's automaton to match. It decides finiteness by
acyclicity, and the certificate's claim must agree; an infinite claim needs a
(prefix, cycle) witness the verifier replays in full.
The verifier shares no completion, ambiguity enumeration, or reduction code with
the engine. An Algebra value exists only after typed verification accepts a
completion certificate. The byte-input verifier also checks certificates loaded
from JSON. Dimension, the Cartan matrix, and every multiplication table
are therefore exact. Nothing in the crate truncates silently.
Two types split the work. Algebra is the runtime algebra and owns its prime
field. The dimension and the structure constants of a general quotient depend on
the field: the ideal generated by ab - 2cd on the square quiver is the
monomial ideal (ab) over F_2 and a non-monomial ideal over F_3, and the two
sides differ in tau and in how rad P_0 decomposes. MonomialIdeal and
MonomialPresentation, in the monomial module, stay field-free and carry the
combinatorics that needs no field: forbidden words, the standard-path
automaton, the exact finiteness decision, dimension, and Cartan data. They
analyze and never construct; monomial_presentation turns a MonomialIdeal
into a Presentation over a field, which then takes the one pipeline every
algebra takes.
Rejected input and exhausted budgets are typed and carry evidence.
AlgebraBuildError::Truncated names the budget that ran out and reports the
basis size, the pending ambiguity count, and the steps consumed.
InfiniteDimensional carries the certificate and a (prefix, cycle) word
witness, so no infinite-dimensional algebra value ever exists. RelationError
names the offending term and what is wrong with it. Verification reports a
verifier rejection of the engine's own certificate: an engine defect that stays
a typed value rather than a panic.
Partial computations say so in their types: projective_dimension returns
Bounded::Exact(n) or Bounded::AtLeast(n), a resolution prefix ends with
ResolutionEnd::Finite or ResolutionEnd::Cut { at }, and no
None-means-infinite convention exists anywhere.
Decomposition, isomorphism, and indecomposability each return a machine-checkable witness or an explicit statement that no witness was found. None of them returns a bare yes.
Every Auslander-Reiten object holds a recheckable witness. A short exact
sequence exists only after per-vertex exactness checks. Split status comes
with a retraction and a section, or with a dual vector proving the
retraction system unsolvable. A Yoneda product can return the chain lifts
that computed it. Almost-split status is never a bare flag:
almost_split gates its result behind an explicit AlmostSplitWitness,
and verify rechecks every gate from the stored data and the live modules.
Enumeration carries a certificate rather than an assertion. A support
tau-tilting pair is verified against the four conditions on any algebra the
crate can build. A complete list of them exists only as a
ClosedSupportTauTiltingGraph, built past a closure witness that rechecks
every vertex and every slot. A walk that stops early keeps its certified part
and claims nothing about completeness.
Higher homological claims pass through checked finite complexes.
CheckedComplex rejects a bad endpoint or nonzero consecutive composite, then
returns either ExactComplex or the first NonExactWitness. The relative
normalized bar construction computes Hochschild cohomology under four explicit
ceilings. A cut retains only finished degrees and names its first rejected
reservation. Classical tilting classification uses the same exact complex for
the generation condition. It distinguishes a positive self-extension from a
projective-dimension or generation bound that leaves the question open.
A verified classical tilting module can recover its split target algebra.
present_target constructs End_A(T)^op for the crate's right-module
convention. It stores a deterministic quiver, relations, the map into
End_A(T), its inverse, and exact work counts. A non-split residue field and a
resource cut are separate typed outcomes. No partial target algebra escapes a
cut.
The non-split outcome states a domain boundary. It is unreachable for a certified tilting module over the supported prime fields: every summand is tau-rigid, and the finite-field obstruction forces residue degree one.
The derived layer checks more than the target ring. BoundedComplex uses
integer homological degrees and provides chain maps, shifts, direct sums,
cones, homotopies, and Hom modulo null-homotopy. StrictTransport applies
Hom_A(T, -) to bounded complexes whose terms carry add(T) witnesses. Its
inverse accepts bounded complexes of projective target modules. A
DerivedEquivalenceCertificate checks the tilting resolution, graded
homotopy self-Hom, the degree-zero endomorphism algebra, and generation.
ExtAlgebraOutcome records deterministic self-Ext spaces and every Yoneda
product tensor through one bound. A finite resolution returns Complete.
Otherwise Cut names the first omitted degree and keeps the exact bounded
layer. The bound alone never makes a claim about higher Ext groups.
Contents
Algebras and modules:
- Prime fields
F_pforp < 2^31, with primality checked at construction. Dense and sparse exact linear algebra over them. RelationandPresentation: validated uniform relations over a quiver and a field.Algebra: the certificate-verified runtime algebra, with the normal-word basis, the reduced Groebner basis (relations), normal forms of arbitrary paths (nf_word), sparse multiplication rows (right_mul,left_mul,mul_basis), and radical powers by row-space iteration.- The
monomialmodule for monomial ideals:MonomialIdealholds the quiver and the minimal forbidden words, andMonomialPresentationadds the certified finite standard-path basis and the Cartan matrix, both field-free. Named constructors, each taking a field:path_algebra,linear_an,kronecker,dual_numbers,truncated_poly,linear_nakayamaandcyclic_nakayama(validated Kupisch series),radical_square_zero_cycle,an_with_relations, andcommutative_square(the relationab - cd). Each monomial family also has an_idealform inmonomialthat stops at the field-free data. - Validated right modules; simples, indecomposable projectives and injectives;
direct sums with inclusions and projections.
Module::newverifies that every element of the reduced Groebner basis acts as zero. - Morphisms with checked commuting squares,
hombases, kernels, images, cokernels; radical, top, socle, and Loewy series.
Homological algebra:
- Minimal projective resolutions via projective covers, projective dimension,
ext_dimandext_table(exact in every degree, even when the projective dimension is unknown), and global dimension. - Minimal injective coresolutions via injective envelopes, and injective
dimension. These are the k-duals of the projective constructions over
A^opand carry the same typed partiality. CheckedComplex: nonempty finite complexes in display order, with checked endpoints and zero composites.exactnessreturnsExactComplexor the firstNonExactWitness, whose homology dimension vector rechecks from the stored maps. A finiteProjectiveResolutionconverts to an exact complex; a cut stays typed.bar_hochschild: relative normalized bar Hochschild cohomology through a requested degree.BarLimitsbounds tensor tuples, cochain dimensions, retained matrix entries plus scratch, and deterministic work. A complete result stores deterministic cocycle, coboundary, and complement bases. An incomplete result stores only the exact prefix andBarBudgetDiagnostics.ClassicalTiltingModule::classify: classical tilting in any finite projective dimension reached by the caller's bound. Success stores the complete minimal resolution, zero positive self-Ext spaces, an exactA -> T^0 -> ... -> T^ngeneration complex, and oneAddClosureWitnessper generated term. A positive self-extension isNotTilting. A bound or blocked bounded generation route isUndetermined.ExtAlgebraOutcome: deterministic self-Ext grades, basis classes, the degree-zero unit, and witnessed Yoneda tensors through a caller bound.BoundedComplex,ChainMap,ChainHomotopy, andHomotopyHom: bounded homological complexes and their deterministic Hom spaces modulo null-homotopy.present_target,StrictTransport, andDerivedEquivalenceCertificate: the split targetEnd_A(T)^op, strict transport on witnessed finite models, and the checked tilting-derived equivalence.
Duality and the Auslander-Reiten translate:
- The opposite algebra, the k-dual
D, and the Nakayama functorν = D ∘ Hom(−, A)applied to presentation maps, with matrices over the algebra rather than over the field (ElementMatrix).νis exposed on maps between projective sums, which is what the translate needs, not as a functor on arbitrary modules. The opposite algebra reverses every relation word and then runs the pipeline again, so it is verified in its own right. taucomputes the translate two ways on every call: the Nakayama kernelker ν(d_1)and the transpose-then-dualD(Tr M)overA^op. The results are cross-checked. The two routes share the minimal presentation and the element-matrix encoding; their back ends are independent, so agreement checks everything downstream of the shared encoding. A certified disagreement and an undecided cross-check are distinct typed errors.
Decomposition and isomorphism:
EndoAlgebra:End(M)as a structure-constant algebra with an exact Jacobson radical overF_pin every characteristic. The radical computation uses the Friedl-Rónyai chain, which never trusts the trace form in small characteristic.decomposeandkrull_schmidt: verified splittings. Each summand carries aCertificate:Indecomposablemeans its endomorphism algebra was proved local;Undeterminedmeans no splitting route succeeded, and the summand may or may not be indecomposable.is_isomorphicreturns one of three outcomes: an isomorphism verified by a checked two-sided inverse; a proof of non-isomorphism as one of fiveObstructionkinds (differing dimension vectors, differing Loewy series, Hom-dimension asymmetry, the radical criterion, or an unmatched Krull-Schmidt summand); orUnknown, which means undetermined rather than "no".
Classification and enumeration:
- Exact recognition of Dynkin and Euclidean type from the underlying graph, the generalized Cartan matrix, and the positive roots. Recognition is combinatorial; nothing in the crate decides a type numerically.
dynkin_indecomposables: every indecomposable of a hereditary path algebra of Dynkin type, one per positive root, constructed through BGP reflection functors (Gabriel's theorem) rather than enumerated and filtered. Preconditions are typed errors: a nonzero ideal or a non-Dynkin graph is reported as such, and a Euclidean quiver is named as Euclidean rather than merely rejected.nakayama_indecomposables: every indecomposable of a Nakayama algebra, each with its certificate.
Ext classes and the witnessed Auslander-Reiten layer:
HomSpace,HomSubspace,HomQuotient:Hom_A(M, N)as an explicit vector space with flat coordinates, RREF subspace bases, and one crate-wide deterministic complement rule, so quotient representatives never depend on the run.IndecomposableModule: a checked wrapper that exists only together with the locality proof of its endomorphism algebra.residue_degreegives the degreedof the residue fieldF_{p^d}.ExtSpaceandExtClass: Ext groups as explicit vector spaces with representative cocycles that recheck by composition. Degree 0 isHom(M, N)and carries the Yoneda unit.thenis the Yoneda product through stored chain lifts;then_with_witnessalso returns the lifts as aProductWitnesswhoseverifyrechecks the lift identities and the reduction.ShortExactSequence: exact per vertex by construction.from_ext1realizes a degree-1 class as an extension,ext1_classrecovers the class, andsplit_statusproves its answer either way: a retraction and section, or a dual vector showing the retraction system inconsistent by multiplication alone.stable_homandalmost_split: Hom modulo the maps that factor through a projective, and almost-split sequences gated behind anAlmostSplitWitness. The AR-duality route stores the socle construction of the chosen class;almost_split_via_cataloginstead stores factorization data against every entry of an exhaustive catalog. A projective input isAlmostSplitOutcome::Projective.category_radical,IndecomposableCatalog,radical_square_through_catalog,irreducible_quotient, andar_quiver: the exact category radical between certified indecomposables, catalogs that wrap complete enumerations for Nakayama, zero-ideal Dynkin, and gentle-tree algebras, catalog-exact rad^2, irreducible morphism spaces, and the valued AR quiver, whose arrows state dimensions over both residue fields instead of a bare multiplicity.
Support tau-tilting:
is_tau_rigidandTauRigidModule:Hom(M, tau M) = 0decided over the ordered pairs of summands, withtaucomputed once per summand through aTauCachekeyed by nominal module identity. A vanishing claim has no element to exhibit, soTauRigidModulestores no positive witness and itsverifyrecomputes every translate. The negative answer does have an element:NonTauRigidWitnesscarries one nonzeroX_i -> tau X_j.SupportTauTiltingPairandAlmostCompletePair: a candidate(M, P)classified against the four conditions, with|M| + |P| = nfor the first andn - 1for the second. A failed condition is aPairRejectionvalue that names the condition, never an error. The four conditions force the projective part, so it is derived rather than searched.mutate_at: left mutation at a module-summand slot. It returns aMutationwith its witness, or aFacWitnessproving thatX_jlies inFac(M/X_j), where the slot admits no left mutation.support_tau_tilting_graph: a breadth-first walk from(A, 0)under left mutation, under four budgets. AClosedSupportTauTiltingGraphexists only pastClosureWitness::verify, and its vertex list is every basic support tau-tilting pair of the algebra up to isomorphism. A walk that stops early is anIncompleteSupportTauTiltingGraph, which keeps the certified part and makes no completeness claim.enumerate_over_catalog: the same pairs from the definition alone over an exhaustiveIndecomposableCatalog, with no mutation and no theorem about the support tau-tilting quiver. Completeness there is the catalog's classification theorem, so the route runs on catalog domains only.
Certificates:
Algebra::certificatereturns the verified certificate, andCertificate::to_canonical_jsonserializes it. The encoding is canonical and carries no timestamps and no machine data, so identical input and identical limits produce identical bytes; the decoder rejects duplicate keys, unknown keys, missing keys, and non-canonical numbers.verifytakes untrusted bytes and returns aVerifiedCompletion, the only way to reachAlgebra::from_verified. Dump, reload, verify, rebuild is a supported workflow.
Capability matrix
Each row says what an operation can return, read off its signature. "Bounded" means the result may be a lower bound tied to a caller-supplied bound. "Undetermined possible" means the operation can end without deciding, and says so.
| Operation | Exact | Bounded | Undetermined possible |
|---|---|---|---|
construction (Algebra::new, monomial_algebra, from_verified) |
yes, after verification | no | no; rejection is AlgebraBuildError |
dim, cartan_matrix, nf_word, radical_power_matrix |
yes | no | no |
resolve, coresolve |
the prefix, exact and minimal | ResolutionEnd::Cut { at } |
no |
projective_dimension, global_dimension, injective_dimension |
Bounded::Exact |
Bounded::AtLeast |
no |
hom_dim, ext_dim, ext_table |
yes, Ext in every degree | no | no |
CheckedComplex::exactness |
ExactComplex, or the first NonExactWitness with exact homology dimensions |
no | no |
bar_hochschild |
Complete through the requested degree |
Cut with the exact completed prefix and first rejected reservation |
no |
ClassicalTiltingModule::classify |
Tilting with all three conditions, or NotTilting with a positive self-extension |
projective dimension and generation have independent caller bounds | yes: Undetermined carries the bound or generation blocker |
present_target |
Presented with End_A(T)^op, or Unsupported with the first non-split residue degree |
Cut with the first rejected reservation |
no |
ExtAlgebraOutcome::compute |
every stored grade and product tensor | Cut names the first omitted degree |
no |
HomotopyHom::quotient |
the deterministic chain Hom quotient | no | no |
DerivedEquivalenceCertificate::new |
the tilting-derived equivalence and strict finite transport | no | no; failed checks are typed errors |
injective_envelope, injective |
yes | no | no |
opposite, dual, nu_of_presentation_map |
yes | no | no |
tau |
the translate, zero exactly on projectives, both routes cross-checked | no | yes: TauError::AgreementUnknown |
decompose, krull_schmidt |
Certificate::Indecomposable, KrullSchmidtOutcome::Classes |
no | yes: Certificate::Undetermined, KrullSchmidtOutcome::Unknown |
is_isomorphic |
Isomorphic with a witness, NotIsomorphic with an obstruction |
no | yes: IsoOutcome::Unknown |
nakayama_indecomposables |
yes, every certificate is Indecomposable |
no | no |
dynkin_indecomposables |
one module per positive root, each with the certificate decompose produced |
no | yes, through that certificate |
IndecomposableCatalog::gentle_tree |
one string module per inverse pair on a checked gentle tree | no | no; unsupported inputs carry the failed check |
CatalogAtlas |
ordered Ext dimensions through the stated degree | setup ceilings reject before table construction | no |
enumerate_multiplicities |
every catalog multiplicity vector at the stated dimension | Cut retains an exact prefix |
no |
catalog_coordinates |
multiplicities and checked isomorphisms | matching limits return Cut |
yes: decomposition or isomorphism may remain unknown |
HomSpace, ExtSpace, stable_hom, category_radical, Yoneda then |
yes | no | no |
ShortExactSequence::from_ext1, ext1_class, split_status |
yes; splitting carries a witness either way | no | no |
IndecomposableModule::new |
yes on acceptance; a split is rejected with its summand count | no | yes: IndecError::Undetermined |
almost_split, almost_split_via_catalog |
Projective, or a sequence with its witness |
no | yes: an undecided tau cross-check or gate surfaces as a typed error |
ar_quiver |
yes, complete for its domain | no | no; any other algebra is UnsupportedDomain with the failed domain checks |
is_tau_rigid, is_tau_rigid_summandwise |
TauRigid with a certified module, NotTauRigid with a nonzero morphism |
no | yes, through the tau cross-check |
SupportTauTiltingPair::classify, AlmostCompletePair::classify |
the pair, or a rejection naming the condition that failed | no | yes, through decomposition and tau |
left_approximation |
the minimal left approximation with its minimality witness | no | no |
mutate_at |
the left mutation with its witness, or a FacWitness proving no left mutation exists |
no | yes, through decomposition and tau |
support_tau_tilting_graph |
Closed, built only past ClosureWitness::verify(), so the pair list is complete |
Incomplete with the limit that fired and its diagnostics |
yes: CertificationBlocked |
tau, the injective constructions, and opposite build the opposite algebra,
so each can also fail with an AlgebraBuildError from that build.
almost_split and ar_quiver run tau and the injective constructions, so
they inherit the same failure modes.
Not included
- Exhaustive catalogs beyond Nakayama, zero-ideal Dynkin, and gentle-tree
algebras. The AR quiver, catalog-exact rad^2, and irreducible morphism
spaces exist only behind an
IndecomposableCatalog, and a catalog wraps a classification theorem; a plain module list never becomes one. Almost-split sequences through the AR-duality route run on any supported algebra. - Infinite complexes, derived categories, Hochschild cup products, Gerstenhaber brackets, and arbitrary coefficient bimodules.
- User-defined admissible orders and one-sided Groebner bases. The order is sealed.
- Characteristic 0.
- Infinite-dimensional quotients. These are rejected with a proof, not supported: the verifier finds a cycle in the normal-word automaton and returns the cyclic word witness.
Conventions
Fixed crate-wide, and documented on the types:
- Paths compose left to right: the word
a·bmeans "firsta, thenb" and requirestarget(a) == source(b). - The admissible order is sealed: degree-lexicographic over the arrow order,
identified in every certificate as
deglex-arrowid-v1. The longer word is the larger word; equal-length words compare lexicographically by arrow id. There are no user-supplied comparators. - Modules are right modules. A module assigns to each vertex
vthe row-vector spacek^{dims[v]}, and to each arrowaadims[source(a)] × dims[target(a)]matrix. A path acts by the product of its arrow matrices in word order, soM(p·q) = M(p) M(q). - A morphism
f: M → Nstores onedim M_v × dim N_vmatrix per vertex, acting on row vectors (x ↦ x f_v). A-linearity is the commuting squaref_{s(a)} · N(a) = M(a) · f_{t(a)}for every arrowa. - Composition is
f.then(g), "firstf, theng": at each vertex the matrix isf_v · g_v. - Cartan matrix:
c[i][j] = dim e_i A e_j. Rowiis the dimension vector of the projectiveP_i = e_i A; columnjis the dimension vector of the injectiveI_j = D(A e_j). - The basis of
Algebrais the normal words:basis[v]is the trivial pathe_vforv < num_vertices, and the rest are sorted by length, then source, then lexicographic arrow word. - A path that is not a normal word is not zero in general.
path_indexreturnsOk(None)for it, andnf_wordgives its normal form as a combination of normal words. Over a monomial ideal the two notions agree andOk(None)does mean zero. - Radical powers are computed as iterated row spaces, never by word length:
J^1is the span of the non-trivial basis words andJ^{k+1}is the span ofx·aoverxspanningJ^k. An inhomogeneous relation puts short normal words into deep radical powers. - The opposite algebra reverses path words, so a right A-module dualizes to a
right
A^op-module.Dis applied throughOppositeMap, which carries the arrow and word translation in both directions. The reversal of a normal word need not be normal on the other side, so every reversed word is expanded to its normal form there.
Quick start
The commutative square kQ/(ab - cd): build it from a relation, resolve a
simple module, and compute the translate.
use Algebra;
use tau;
use CompletionLimits;
use PrimeField;
use Module;
use ;
use ;
use ;
let field = new.unwrap;
// Arrows a: 0 → 1, b: 1 → 3, c: 0 → 2, d: 2 → 3.
let quiver = new.unwrap;
// The relation ab - cd. Terms may be listed in any order.
let relation = new
.unwrap;
let presentation = new.unwrap;
// Completion, certificate emission, and verification of the bytes.
let algebra = new.unwrap;
assert_eq!;
let s0 = simple;
let resolution = resolve;
let terms: = resolution.terms.iter.map.collect;
// 0 → P_3 → P_1 ⊕ P_2 → P_0 → S_0 → 0.
assert_eq!;
assert_eq!;
// τ S_0, computed by two independent routes and cross-checked. The result is
// the zero module exactly when the input is projective.
assert_eq!;
The same algebra is available as commutative_square(field).
The Ext table of the simples of kA_3/(ab), the algebra of the linearly oriented
quiver 0 → 1 → 2 with the composite path set to zero:
use an_with_relations;
use ext_table;
use PrimeField;
use Module;
let field = new.unwrap;
let algebra = an_with_relations.unwrap;
let s0 = simple;
let s2 = simple;
// [dim Ext^0, ..., dim Ext^4]: the relation from 0 to 2 sits in Ext^2.
assert_eq!;
The checked example converts the projective resolution of S_0 over
kA_3/(ab) into an ExactComplex, computes
HH^0..HH^2(k[x]/(x^3)) = (3, 2, 2), checks a zero-work bar cut, and certifies
D(A) as a classical tilting module of projective dimension two over F_2 and
F_5:
The tilting certificate stores this exact generation complex:
[1, 2, 2] -> [1, 3, 2] -> [1, 1, 0] -> [1, 0, 0]
The complete Rust example and its Python acceptance path are part of the repository test suite.
The classical_tilting example continues from the same
projective-dimension-two tilting module. It recovers End_A(T)^op, checks the
derived-equivalence certificate, transports a two-term add(T) complex in
both directions, and compares its graded homotopy Hom dimensions:
The example prints:
target dimension: 5; resolution width: 2; graded Hom dimensions: [(-2, 0), (-1, 3), (0, 6), (1, 3), (2, 0)]
Both strict round-trip chain isomorphisms pass verification. The derived workbench example adds ordinary-complex replacement, derived Hom, automatic transport, tilting-complex discovery, target recovery, and a verified portable artifact.
Decomposing a module and reading the certificates:
use truncated_poly;
use ;
use PrimeField;
use ;
let field = new.unwrap;
let algebra = truncated_poly.unwrap;
let p = projective;
let s = simple;
let = direct_sum;
let d = decompose;
assert_eq!;
// Every summand was proved indecomposable, not merely left unsplit.
assert!;
The witnessed AR layer over k[x]/(x^3): certify the simple module
indecomposable, build its almost-split sequence, recheck the witness, and read
the valued AR quiver.
use truncated_poly;
use ;
use ar_quiver;
use PrimeField;
use IndecomposableModule;
use Module;
let field = new.unwrap;
let algebra = truncated_poly.unwrap;
let s = new.unwrap;
// 0 → S → rad P → S → 0: the middle term is the uniserial module of dimension 2.
let Sequence = almost_split.unwrap else ;
println!;
assert_eq!;
// The witness rechecks every gate of the construction against the live modules.
let ArDuality = sequence.witness else ;
assert!;
// Three uniserial indecomposables, four irreducible arrows.
let quiver = ar_quiver.unwrap;
assert_eq!;
assert_eq!;
The examples run as acceptance tests. Their displayed values are pinned by the test suite.
Python
Bindings live in crates/auslander-py; the PyPI package is auslander.
For a source build, install maturin and run:
The Python surface covers general relations
(Algebra.from_relations(quiver, relations, field)), the certificate workflow
(algebra.certificate_json() and Algebra.from_certificate(json)), the
witnessed AR layer (ext_space, extension, almost_split,
category_radical, ar_quiver), checked finite complexes, budgeted Hochschild
cohomology, classical tilting, target recovery, bounded Ext algebras, homotopy,
and strict derived transport. Python uses the same typed outcomes and checked
round trips as Rust.
See crates/auslander-py/README.md.
Building and testing
MSRV 1.88; development is pinned to Rust 1.92 via rust-toolchain.toml:
Release workflows configure non-publish workflow_dispatch rehearsal and
hosted ARM and macOS architecture checks. Those jobs are GitHub-hosted runner
configuration. They are not a local execution record.
Correctness protocol
The test suite checks exact fixtures, typed cuts, witness replay, deterministic bytes, characteristic-sensitive cases, and a committed GAP+QPA oracle. See the correctness protocol for the full matrix.
License
Licensed under either of the MIT license (LICENSE-MIT) or the Apache License,
Version 2.0 (LICENSE-APACHE), at your option.