09 — The Chouhy–Solotar resolution¶

What this computes¶

Given A = kQ/I (any admissible presentation, any exact field), the CS engine builds a small projective resolution of A as an A-bimodule and reads Hochschild (co)homology off it — reaching degrees the bar complex never can.

The objects (how they are represented in code)¶

Reduction system rs (quiverlab.groebner.build_reduction_system): the confluent rewriting rules s → f_s. rs.leading_words() are the tips S; rs.irreducibles a basis of A. Words are tuples of arrow NAMES, left to right.
Ambiguity chain Chain (resolutions_cs.terms): an element of S_n. word is the path; blocks = (u_0,…,u_{n-1}) its unique CS left decomposition; o,t its endpoints. S_0=vertices, S_1=arrows, S_2=tips, S_n (n≥3) = (n-1)-fold overlaps of tips. Computed by reusing Bardzell's associated_paths on the tip monomial algebra A_S. Since Plan 12, blocks are cut at first reducibility (the witness tip may straddle a block boundary as a proper suffix of the pair — with mixed-length tips the pair need not itself be a tip), and each chain also has a right decomposition (v_{n-1},…,v_0) (right_decomposition, mirror-greedy from the last arrow), used by the odd differential.
Resolution term P_n = ⨁_{σ∈S_n} A e_{o(σ)} ⊗ e_{t(σ)} A. Tensoring/homming down, each σ contributes the corner e_tAe_o (homology) or e_oAe_t (cohomology).
A term (coeff, a, τ, c) means coeff · (a ⊗ τ ⊗ c); a,c are paths, τ ∈ S_{n-1}.

The computation, step by step (on k[x]/(x²))¶

Tips S = {xx}. S_n = {x^n}; P_n ≅ A^e; collapsed C_n = A = ⟨1,x⟩.
Leading map: d_n odd = x⊗1 − 1⊗x; even = 1⊗x + x⊗1. No correction (monomial).
Collapse to C_n: odd ↦ 0; even ↦ multiply-by-2x = [[0,0],[2,0]], rank 1.
HH_n = dim C_n − rank d_n − rank d_{n+1} = [2,1,1,1,…] (char 0); [2,2,…] (char 2).

The differential in general (the two subtle steps)¶

The leading map δ_n is Bardzell's (depends only on the tips). For n odd (the 2-term map) its first term is v_top ⊗ (rest) ⊗ 1 with v_top the leftmost block of the right factorization (CS §4 f_n, n even) — equal to u_0 only for quadratic tips (CS Prop. "cuadratico") or palindromic families; e.g. for tips {xx,yy,yxy} and the straddle chain yxyy the terms are (+1, yx, yy, ()), (−1, (), yxy, y). The tails then add a correction strictly below σ in the reduction order; its coefficients are the solution of the linear system d_{n-1}∘d_n = 0 (CS Theorems 4.1/4.2 — the same trick CS use in §6). Two gates certify every run: assert_dd_zero and assert_order_condition.

The canonical form (Plan 17). The correction solution γ is unique only modulo the system's nullspace (on the quantum-CI family the nullity grows with degree), so _d_general reduces it through fields.linalg.reduce_mod_nullspace — the unique coset representative with zero coordinates at every free (non-pivot) column of the system's RREF. That makes the CS differential byte-reproducible by construction: which particular solution the solver returns no longer matters (an adversarial test shifts the solve by a nullspace vector and demands byte-identical d_n). The representative happens to coincide with both the solver's own free-variables-zero convention and the bank's hand-derived closed forms, so the byte-level bank pins and the paper's d₂ coefficient pin are strict tests since this plan. A coset move never touches d² = 0 (same linear system) or the order condition (every candidate generator is ≺ σ by construction).

Worked non-monomial example — the commutative square (HH^• = (1,0,0))¶

A = kQ/(ab − cd), Q: 1→2→4, 1→3→4 (arrows a,b,c,d), tip cd, dim A = 9. S_0 = {e_1,e_2,e_3,e_4}, S_1 = {a,b,c,d}, S_2 = {cd}, S_n = ∅ (n≥3). Cohomology terms: C^0 = ⟨ê_1..ê_4⟩ (dim 4), C^1 = ⟨â,b̂,ĉ,d̂⟩ (dim 4), C^2 = ⟨âb⟩ (dim 1).

δ^0 sends (λ_1,λ_2,λ_3,λ_4) ↦ ((λ_2−λ_1)a, (λ_4−λ_2)b, (λ_3−λ_1)c, (λ_4−λ_3)d):

        e1  e2  e3  e4
   a  [ -1   1   0   0 ]
   b  [  0  -1   0   1 ]        rank 3,  ker = <(1,1,1,1)> = the centre  ⟹  HH^0 = 1
   c  [ -1   0   1   0 ]
   d  [  0   0  -1   1 ]

δ^1 sends a 1-cochain g(a)=αa, g(b)=βb, g(c)=γc, g(d)=δd to (δ+γ−β−α)·ab:

        a   b   c   d
  cd  [ -1  -1   1   1 ]        rank 1  ⟹  HH^2 = 1 − 1 = 0

HH^0 = 4 − rank δ^0 = 1, HH^1 = (4 − rank δ^1) − rank δ^0 = 3 − 3 = 0, HH^2 = 1 − rank δ^1 = 0. Three cross-checks agree: Euler 4 − 4 + 1 = 1; Gerstenhaber–Schack (order complex of the diamond poset = two triangles glued on {1,4} = contractible ⟹ HH^{>0}=0); Künneth (A = kA_2 ⊗ kA_2, kA_2 a hereditary tree ⟹ HH^0=k, HH^{≥1}=0). Homology instead gives HH_• = (4,0,0) (the quiver is acyclic, so C_1 = C_2 = 0 and HH_0 = A/[A,A] = k^{|Q_0|} = k^4); A is not symmetric, so HH_0 = 4 ≠ 1 = HH^0.

The lifted diagonal and the native cup (Plan 20)¶

Past the bar window the cup product is computed natively on the CS small model, with no bar object ever built — a diagonal approximation Δ: P → P ⊗_A P built degreewise, the same way the comparison map Φ is built.

The ambient: P_p ⊗_A P_q as a double-PELT. The tensor product of the CS resolution with itself, P_p ⊗_A P_q = ⨁_{τ∈S_p, ρ∈S_q} A e_{o(τ)} ⊗ e_{t(τ)}A e_{o(ρ)} ⊗ e_{t(ρ)}A, is again a projective A^e-resolution of A, so a diagonal chain map lifting id_A exists and is unique up to homotopy. Its elements live in a double-PELT dict (resolutions_cs/diagonal.py) that extends the single-PELT of pelt.py: a key (a, τ, mid, ρ, c) means coeff·(b_a ⊗ τ ⊗ b_mid ⊗ ρ ⊗ b_c), where b_a ∈ A e_{o(τ)}, b_mid ∈ e_{t(τ)}A e_{o(ρ)} is the interior corner factor glued along the middle A-slot, and b_c ∈ e_{t(ρ)}A.

The tensor differential and its ONE sign. d^{P⊗P}_n = d_p⊗1 + (−1)^p·1⊗d_q on the P_p ⊗_A P_q summand — the Koszul sign sits on the second summand only, and nowhere else. Each summand is applied by gluing a d_terms output into a slot exactly as pelt.apply_lower glues into a single-PELT (slot 1 multiplies the produced factors into the a- and mid-slots; slot 2 into the mid- and c-slots, carrying the (−1)^p). (d^{P⊗P})² = 0 is gated as an exact matrix identity per corner, plus a hand-computed Koszul-sign pin on k[x]/(x³).

The lift-solve — why no contracting homotopy is needed. The CS resolution exposes no contracting homotopy (and the Ψ-synthesis routes are blocked by the unbuilt chain-level Ψ), so Δ is built degreewise by solving the lifting equation d^{P⊗P}_n · Δ_n(σ) = Δ_{n−1}(d_n σ) for each generator σ ∈ S_n. The right-hand side ζ(σ) = Δ_{n−1}(d_n σ) is assembled by the OUTER bimodule action of d_n σ on the cached Δ_{n−1} (distinct from the INTERIOR gluing of apply_tensor_d); the equation is then a plain linear system over the domain — coefficient matrix tensor_matrix(n, o(σ), t(σ)), one corner at a time. This is the exact structural clone of _d_general's correction solve: fields.linalg.solve then reduce_mod_nullspace. Base case Δ_0(σ_v) = e_v ⊗ σ_v ⊗ e_v ⊗ σ_v ⊗ e_v.

Canonical, byte-reproducible. As in Plan 17, the particular solution is reduced to its free-variables-zero coset representative, so Δ — and every native cup vector read off it — is byte-reproducible run to run (two fresh resolutions give identical Δ dicts).

The scope edge is the SAME one _d_general flags. An inconsistent lift-solve raises the identical loud NotImplementedError ("higher CS homotopy correction … spec §6 risk register") — never a silent fallback, and reachable only where the correction solve is itself inconsistent (the same per-instance certification model the differential carries).

The cup collapse is sign-free. For CS cochains f ∈ C^p, g ∈ C^q, (f∪g)(σ) = Σ_Δ coeff · a·f(τ)·mid·g(ρ)·c — the a·w·b cohomology collapse generalized to two interior values, matching the engine's bar cup convention. All Koszul sign already lives inside Δ; the collapse adds none. The Leibniz identity δ(f∪g) = (δf)∪g + (−1)^p f∪(δg) is the arbiter that pins the sign placement (an exact GF(p) gate on the full cochain basis); graded-commutativity and associativity hold mod coboundary on HH representatives, and in-window the native cup is cohomologous to the transported cup — a permanent anchor oracle (the multi-vertex comm_square even matches transport exactly as cochains, where HH² = 0 makes the class test vacuous).

The native cap (Plan 21)¶

Past the window the cap product is computed natively too, by reading the SAME lifted diagonal Δ the HOMOLOGY way — the covariance flip is the whole idea, exactly as in the minimal engine's Plan-16 note (cohomology acts a·w·b, HOMOLOGY acts b·w·a on SWAPPED corner tags; engine/resolutions_minimal.py). For a double-PELT key (a, τ, mid, ρ, c) of the (p, n-p)-component of Δ_n(σ) (deg τ = p, deg ρ = n-p), a cochain f ∈ C^p capped with a chain z ∈ C_n (value x = z(σ) ∈ e_{t(σ)}A e_{o(σ)}) lands in C_{n-p}, supported on ρ, with

(f ∩ z)(ρ) = Σ_Δ coeff · b_c · x · b_a · f(τ) · b_mid — SIGN-FREE.

f eats the degree-p first factor τ, ρ survives, and the x ⊗_{A^e} P_{n-p} collapse is the op-twisted R·x·L (L = b_a·f(τ)·b_mid, R = b_c) the homology differential already uses (resolution.py:187). The value reads against corner(o(ρ), t(ρ), "hom"); no bar object is built, so it works at ANY degree (resolutions_cs/cap.py; Comparison.cap_of_cs_classes(engine="auto"/"native"/ "transport") routes native past-window, transported in-window byte-unchanged). Signs are again arbitrated, not assumed: the in-window native ≡ transported cap_of_cs_classes anchor (the non-commutative quantum CI distinguishes b·w·a from a·w·b), the exact unit cap 1 ∩ z = z, the exact cap-Leibniz b(f∩z) = (−1)^{p+1}(δf∩z) + (−1)^p(f∩bz), and the module identity (z∩f)∩g ~ z∩(f∪g) (HH_• a module over HH^•, using the native cup for f∪g) all hold simultaneously with the sign-free collapse. Degree edges: n = p lands in C_0; p > n raises ValueError (a cap into negative degree, bar convention).

Honest scope table (CS Hochschild operations).

operation	in the bar window	past the window
cup	transported (Plan 14) ≡ native, mod coboundary	native ✓ (Plan 20)
cap	transported `cap_of_cs_classes` (Plan 14) ≡ native, mod boundary	native ✓ (Plan 21) — same Δ, homology-side `b·w·a` collapse
bracket	transported (Plan 14)	window-bounded by design — going native needs the CS brace/circle machinery, not built in quiverlab v1

What is certified, and what is not¶

Deep dims: certified for k[x]/(x^a) and the quantum CI (byte-oracle) to any depth.
General kQ/I: computed for every admissible presentation (Plan 12 lifted the quadratic-or-monomial restriction via right_decomposition), certified per instance by d²=0 + order gate + bar-window agreement. The only remaining refusal is a genuinely inconsistent correction solve (NotImplementedError at that exact (n, σ)).
Operations (cup/cap/bracket): transported to bar and back, certified only in the bar window — but since Plan 14 for every admissible presentation (the comparison map is built by the homotopy lift Φ_n = h∘Φ_{n-1}∘d_n through the normalized bar's contracting homotopy, replacing the closed forms that were valid only for single-arrow blocks; cap transports through the covariant collapse A ⊗ Φ, Comparison.cap_of_cs_classes). Per-instance gates: assert_chain_map, transport roundtrip, cup-route agreement, unit-cap and (z∩f)∩g ~ z∩(f∪g). Past the window: the cup (Plan 20) and the cap (Plan 21) are both delivered natively via the lifted diagonal — the cup the a·w·b cohomology way, the cap the b·w·a homology way (see "The native cap" above); the bracket stays transported/window-bounded by design.