Plan 35 wave 3c -- the classical DICTIONARY: what each (co)homology space MEANS.
Marco: the report must be "complete with all interpretations of the spaces". Every
homological invariant quiverlab computes is a vector space whose ELEMENTS carry standard
representation-theoretic meaning -- Ext classes are exact sequences, HH^1 classes are
derivations, HH^2 classes are infinitesimal deformations, HH_0 is the commutator
quotient, and so on. This module is the SINGLE shared source of that interpretation
prose so the report HTML and both GUI renderers state it identically, never drifting.
Two honesty rules, enforced by construction:
- CONSTRUCTED vs FRAMING. Where the capture layer records the actual class data (Ext
Yoneda sequences in
modules.complex_reps; the per-degree cochain / cycle reps in
the HH product + cyclic blocks) the interpretation is backed by explicit objects.
Where only the dimension is known (the plain HH / cyclic dims tables carry no
per-class reps yet), the sentence states the STANDARD meaning of the space and is
plainly a framing sentence -- it never invents element-wise data.
- Degrees beyond the elementary dictionary (HH^{>=3}, higher Ext / Tor) get the honest
homological framing (Yoneda / obstruction / derived-functor), explicitly labelled as
framing, not a fabricated concrete meaning.
Sentences are PLAIN unicode text (light math as HH^0, M (x)_A N, 0 -> N -> E
-> M -> 0), so the report's MathML surface and the GUIs' MathJax surface render the
SAME string identically -- the heavy math (the exact sequences, the matrices) goes
through each surface's proper math path, not through this prose. Float-free.
central_element
From a degree-0 HH^0 cochain's term-sum, the central element z of Z(A).
Source code in src/quiverlab/trace/interpretations.py
| def central_element(terms):
"""From a degree-0 HH^0 cochain's term-sum, the central element ``z`` of ``Z(A)``."""
return _element_from_terms(terms)
|
commutator_residue
commutator_residue(terms)
From a degree-0 HH_0 chain's term-sum, the residue in A / [A, A].
Source code in src/quiverlab/trace/interpretations.py
| def commutator_residue(terms):
"""From a degree-0 HH_0 chain's term-sum, the residue in ``A / [A, A]``."""
return _element_from_terms(terms)
|
deformation_cochain(terms)
From a degree-2 HH^2 cochain's term-sum [[coeff, [a, b], value], ...], the
infinitesimal-deformation 2-cocycle values μ(a, b) = coeff * value, grouped by
the argument pair (in first appearance order).
Source code in src/quiverlab/trace/interpretations.py
245
246
247
248
249
250
251
252
253
254
255
256 | def deformation_cochain(terms):
"""From a degree-2 HH^2 cochain's term-sum ``[[coeff, [a, b], value], ...]``, the
infinitesimal-deformation 2-cocycle values ``μ(a, b) = coeff * value``, grouped by
the argument pair (in first appearance order)."""
by_pair, order = {}, []
for coeff, word, value in terms:
pair = _arrow_word(word)
if pair not in by_pair:
by_pair[pair] = []
order.append(pair)
by_pair[pair].append(_magnitude(coeff, value))
return ["μ(%s) = %s" % (pair, " + ".join(by_pair[pair])) for pair in order]
|
derivation_values
From a degree-1 HH^1 cochain's labelled term-sum [[coeff, word, value], ...]
(each word a single arrow generator, as a bare label or a 1-element list), the
derivation's action list D(arrow) = coeff * value, grouped by arrow. Presentation
only: it relabels the already-shipped terms as D(.) values, inventing nothing.
Source code in src/quiverlab/trace/interpretations.py
224
225
226
227
228
229
230
231
232 | def derivation_values(terms):
"""From a degree-1 HH^1 cochain's labelled term-sum ``[[coeff, word, value], ...]``
(each ``word`` a single arrow generator, as a bare label or a 1-element list), the
derivation's action list ``D(arrow) = coeff * value``, grouped by arrow. Presentation
only: it relabels the already-shipped terms as D(.) values, inventing nothing."""
by_arrow = {}
for coeff, word, value in terms:
by_arrow.setdefault(_arrow_word(word), []).append(_magnitude(coeff, value))
return ["D(%s) = %s" % (a, " + ".join(by_arrow[a])) for a in sorted(by_arrow)]
|
element_heading
element_heading(theory, n)
The interpretation heading for (theory, degree n)'s element-wise read-off, or
None when that space has no element-wise dictionary entry.
Source code in src/quiverlab/trace/interpretations.py
| def element_heading(theory, n):
"""The interpretation heading for ``(theory, degree n)``'s element-wise read-off, or
``None`` when that space has no element-wise dictionary entry."""
entry = _ELEMENT_READOFF.get((theory, int(n)))
return entry[0] if entry is not None else None
|
element_readoff
element_readoff(theory, n, terms)
The element-wise dictionary read-off of ONE class's labelled term-sum -- a list of
display strings -- or None when (theory, degree n) has no element-wise entry
(the framing sentence applies instead).
Source code in src/quiverlab/trace/interpretations.py
| def element_readoff(theory, n, terms):
"""The element-wise dictionary read-off of ONE class's labelled term-sum -- a list of
display strings -- or ``None`` when ``(theory, degree n)`` has no element-wise entry
(the framing sentence applies instead)."""
entry = _ELEMENT_READOFF.get((theory, int(n)))
return entry[1](terms) if entry is not None else None
|
ext_degree
The meaning of a class of Ext^n_A(M, N).
Source code in src/quiverlab/trace/interpretations.py
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116 | def ext_degree(n):
"""The meaning of a class of Ext^n_A(M, N)."""
if n == 0:
return ("Ext⁰(M, N) = Homₐ(M, N): its basis classes are the "
"A-module homomorphisms M → N.")
if n == 1:
return ("Each basis class of Ext¹(M, N) is a short exact sequence "
"0 → N → E → M → 0 (a Baer extension of M by N), up "
"to equivalence. Below, each extension module E is constructed explicitly "
"as a pushout and its exactness is verified.")
return ("Each basis class of Extⁿ(M, N) is an n-fold exact sequence "
"0 → N → Q → P_{n-2} → ⋯ → P_0 → M → 0 "
"(Yoneda), up to equivalence. Below, each is spliced explicitly from the "
"pushout module Q and the minimal resolution of M, and its exactness is "
"verified at every joint.")
|
hh_space_typing
hh_space_typing(theory, route)
The one-paragraph typing statement for an HH cohomology / homology section.
Source code in src/quiverlab/trace/interpretations.py
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81 | def hh_space_typing(theory, route):
"""The one-paragraph typing statement for an HH cohomology / homology section."""
coh = theory in ("hh_cohomology", "HH^")
if route == "cs":
if coh:
return ("What the engine computes: Hochschild cohomology as the cohomology "
"of Hom_{A^e}(P_•, A), where P_• → A is the Chouhy–Solotar projective "
"bimodule resolution with P_n = ⊕_σ A e_{o(σ)} ⊗ e_{t(σ)} A (σ over "
"the degree-n ambiguity chains). Degree n collapses to the corner "
"space C^n = ⊕_σ e_{o(σ)} A e_{t(σ)}. A basis element v ⊗ p pairs a "
"path v ∈ A with a chain word p = a_1·a_2·…. The word p NAMES the "
"free generator of P_n attached to that degree-n chain (an "
"iterated overlap of the relations): it is not the product of its "
"letters in A -- that product is typically zero there, the "
"generator never is. A cochain [p → v] sends THAT generator to "
"v ∈ A." + _NOTATION_TAIL)
return ("What the engine computes: Hochschild homology as the homology of "
"A ⊗_{A^e} P_•, where P_• → A is the Chouhy–Solotar projective bimodule "
"resolution with P_n = ⊕_σ A e_{o(σ)} ⊗ e_{t(σ)} A. Degree n collapses "
"to the corner space C_n = ⊕_σ e_{t(σ)} A e_{o(σ)}. A basis element "
"v ⊗ p pairs a path v ∈ A with a chain word p = a_1·a_2·…. The word "
"p NAMES the free generator of P_n attached to that degree-n chain "
"(an iterated overlap of the relations): it is not the product of "
"its letters in A -- that product is typically zero there, the "
"generator never is." + _NOTATION_TAIL)
if coh:
return ("What the engine computes: Hochschild cohomology as the cohomology of "
"the normalized bar cochain complex. A degree-n cochain is a k-linear "
"map C^n = Hom_k(Ā^⊗n, A), where Ā = A/(k·1) is the algebra modulo its "
"unit (spanned by the arrows and longer paths); by the tensor–hom "
"adjunction this is Hom_{A^e}(A ⊗ Ā^⊗n ⊗ A, A), a bimodule map out of "
"the n-th term of the bar resolution of A. A basis functional written "
"[w_1 ⊗ … ⊗ w_n ↦ v] sends the single basis tensor w_1 ⊗ … ⊗ w_n "
"(each w_i ∈ Ā) to v ∈ A and every other basis tensor to 0. The "
"argument is a TENSOR over k, not a product in A: w ⊗ w is a basis "
"element of Ā^⊗2 and stays nonzero even when w·w = 0 in A."
+ _NOTATION_TAIL)
return ("What the engine computes: Hochschild homology as the homology of the "
"normalized bar chain complex C_n = A ⊗_k Ā^⊗n (equivalently "
"A ⊗_{A^e} (A ⊗ Ā^⊗n ⊗ A)). A basis chain written v ⊗ w_1 ⊗ … ⊗ w_n has "
"v ∈ A and each w_i ∈ Ā. It is a TENSOR over k, not a product in A: "
"v ⊗ w ⊗ w stays nonzero even when w·w = 0 in A." + _NOTATION_TAIL)
|
module_reps_label_note
module_reps_label_note(kind)
The Ext / Tor class-label explanation (Marco 2026-07-31): what P_v, P_v#k and
n_{v,j} denote in a term-sum. kind is "ext" / "tor".
Source code in src/quiverlab/trace/interpretations.py
84
85
86
87
88
89
90
91
92
93
94
95
96 | def module_reps_label_note(kind):
"""The Ext / Tor class-label explanation (Marco 2026-07-31): what P_v, P_v#k and
n_{v,j} denote in a term-sum. ``kind`` is "ext" / "tor"."""
common = ("Notation. In a class term-sum, P_v is the generator of the projective "
"summand A e_v of the resolution term P_n, and P_v#k the k-th copy of "
"P_v when the vertex v repeats among the summands of P_n; ")
if kind == "ext":
return (common + "n_{v,j} is the j-th basis vector of the vertex-v part N e_v "
"of N. A basis functional [P_v#k → n_{w,j}] is the A-linear map sending "
"that generator to n_{w,j} and every other generator to 0.")
return (common + "n_{v,j} is the j-th basis vector of the vertex-v part e_v N of N. "
"A basis element P_v#k ⊗ n_{w,j} is the tensor of that generator with "
"n_{w,j} in P_n ⊗_A N.")
|
sentence
The interpretation sentence for (theory, degree n), or None if the
theory has no dictionary entry.
Source code in src/quiverlab/trace/interpretations.py
| def sentence(theory, n):
"""The interpretation sentence for ``(theory, degree n)``, or ``None`` if the
theory has no dictionary entry."""
fn = _THEORY.get(theory)
return fn(int(n)) if fn is not None else None
|
tor_degree
The meaning of a class of Tor_n^A(M, N).
Source code in src/quiverlab/trace/interpretations.py
119
120
121
122
123
124
125
126
127
128
129
130 | def tor_degree(n):
"""The meaning of a class of Tor_n^A(M, N)."""
if n == 0:
return ("Tor₀(M, N) = M ⊗ₐ N, the tensor product itself: the "
"coequalizer of the two actions M ⊗ A ⊗ N ⇉ M ⊗ N. "
"Its classes are the cosets m ⊗ n.")
if n == 1:
return ("Tor₁(M, N) measures the failure of M (equivalently N) to be flat: "
"a nonzero class is a syzygy relation among the generators that "
"− ⊗ N does not see, i.e. an obstruction to flatness.")
return ("Torₙ(M, N) is the n-th derived functor of − ⊗ₐ N at M: "
"a higher syzygy / flatness obstruction (homological framing).")
|