# Strong cotilting module for radical square zero algebras

Given a connected Artin algebra $A$ (a quiver algebra $A=kQ/I$ if it helps) with radical square zero. Can the basic strong cotilting right $A$-module $T$ be explicitly written down?

A cotilting module T over an algebra A is said to be strong in case $\widehat{\mathrm{add}(T)}$ coincides with the subcategory of modules having finite injective dimension.

Here $\widehat{\mathrm{add}(T)}$ is just the full subcategory of all modules $M$ such that there is an exact sequence $0 \rightarrow T_n \rightarrow \cdots \rightarrow T_0 \rightarrow M \rightarrow 0$ with $T_i \in \mathrm{add}(T)$.

I try to compute this $T$ using QPA for such algebras but at the moment it only works in the representation-finite case and maybe at least for radical square zero algebras this $T$ can be explicitly calculated by QPA.

I discuss the dual problem of how to compute the strong tilting module $T$.

Following Auslander-Reiten (AR) let me denote by $\mathcal{P} = \mathcal{P}^\infty(A)$ the full subcategory of $\mathrm{mod}(A)$ consisting of modules with finite projective dimension.

Let $\mathfrak{a}$ be the sum of all (simple) submodules in $\mathrm{rad}(A)$ with finite projective dimension. Then $\mathfrak{a}$ is the ideal of $A$ arising as the trace of $\Omega(\mathrm{mod}(A)) \cap \mathcal{P}$ in $\mathrm{rad}(A)$. Section 4 of AR now tells us that $\mathcal{P}$ is contravariantly finite and arXiv:1504.08282 that the strong tilting module $T$ can be computed as the direct sum of the minimal right $\mathcal{P}$-approximations of the indecomposable injective $A$-modules.

Let's discuss how to do this in some detail:

• According to AR, the minimal right $\mathcal{P}$-approximation $f_S$ of a simple $A$-module $S$ is its minimal projective cover as an $A/\mathfrak{a}$-module. This means, assuming $P_S \to S$ is the minimal projective cover as $A$-modules, we can choose $f_S$ to be the induced map $P_S/\mathfrak{a} \to S$. Of course, taking $f_S = \mathrm{id}_S$ is possible in case $S$ has finite projective dimension.

• We now construct the approximation $T \to I$ of the minimal injective cogenerator $I = \bigoplus_S I_S$ by using the approximations of the simples $S$. For this, consider for each simple module $S$ the minimal right $\mathcal{P}$-approximation $f = \oplus_{S'} f_{S'}$ of the semisimple module $\mathrm{top}(I_S) = \bigoplus_{S'} {S'}$.

On the one hand, if $S$ has finite projective dimension, taking the pullback $\require{AMScd}$ \begin{CD} T_S @>>> \textstyle\bigoplus_{S'} P_{S'}/\mathfrak{a} \\ @V{g_S}VV @VV{f}V \\ I_S @>>> \mathrm{top}(I_S) \end{CD} yields a right $\mathcal{P}$-approximation $g_S$ (see Section 3 in AR). Note that $S$ is by construction the unique simple submodule of $T_S$ having finite projective dimension, which implies that $T_S$ is indecomposable and $g_S$ right minimal.

On the other hand, if $S$ has infinite projective dimension, we will take for $g_S$ the induced map $\bigoplus_{S'} P_{S'}/\mathfrak{a} \to I_S$ in the following commutative square: \begin{CD} \textstyle\bigoplus_{S'} P_{S'} @>>> \textstyle\bigoplus_{S'} P_{S'}/\mathfrak{a} \\ @VVV @VV{f}V \\ I_S @>>> \mathrm{top}(I_S) \end{CD} That $g_S$ is a minimal right $\mathcal{P}$-approximation can be deduced from the fact that $\Omega(M) \in \mathrm{add}(\mathfrak{a})$ for all $M$ in $\mathcal{P}$. We choose $T_S = P_S/\mathfrak{a}$ and observe that all summands $S'$ of $\mathrm{top}(I_S)$ have infinite projective dimension.

All in all, we can conclude $\mathrm{add}(T) = \mathrm{add}(\bigoplus_S T_S)$.

Here is an attempt to implement this algorithm with QPA:

LoadPackage("qpa");

DirectSumOfMaps := function(maps)
local M, N, p, q, i, result;

if IsEmpty(maps) then
return fail;
fi;

M := DirectSumOfQPAModules(List(maps, f -> Source(f)));
N := DirectSumOfQPAModules(List(maps, f -> Range(f)));

p := DirectSumProjections(M);
q := DirectSumInclusions(N);

result := ZeroMapping(M, N);

for i in [1..Length(maps)] do
result := result + p[i]*maps[i]*q[i];
od;

return result;
end;

StrongTiltingModule := function(A)
local n, i, j, S, F, L, s, r, t, q, g, d, T;

Error("this is not a radical-square-zero algebra,\n");
fi;

S := SimpleModules(A);
n := Length(S);

Perform(S, s -> ProjDimensionOfModule(s, n));

F := DirectSumOfQPAModules(Filtered(S, s -> HasProjDimension(s)));
if F = fail then
F := ZeroModule(A);
fi;

L := [];
for s in S do
if HasProjDimension(s) then
else
r := KernelInclusion(ProjectiveCover(s));
t := TraceOfModule(F, Source(r));
q := IdentityMapping(Range(r));
fi;
od;

T := [];
for i in [1..n] do
if HasProjDimension(S[i]) then
q := CoKernelProjection(InjectiveEnvelope(S[i]));
d := DimensionVector(Range(q));
g := [];
for j in [1..n] do
Append(g, ListWithIdenticalEntries(d[j], L[j]));
od;
if IsEmpty(g) then