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;
if not IsRadicalSquareZeroAlgebra(A) then
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
Add(L, IdentityMapping(s));
else
r := KernelInclusion(ProjectiveCover(s));
t := TraceOfModule(F, Source(r));
q := IdentityMapping(Range(r));
Add(L, MorphismOnCoKernel(t*r, r, t, q));
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
Add(T, Source(q));
else
Add(T, Source(PullBack(q, DirectSumOfMaps(g))[1]));
fi;
else
Add(T, Source(L[i]));
fi;
od;
return DirectSumOfQPAModules(T);
end;
```