This is a manual of tors_lattice.py, a module for SageMath which can deal with the lattice of torsion classes of a $\tau$-tilting finite algebra and construct various objects from it.

[AP] S. Asai, C. Pfeifer,

*Wide subcategories and lattices of torsion classes*, arXiv:1905.01148.[BTZ] E. Barnard, G. Todorov, S. Zhu,

*Dynamical combinatorics and torsion classes*, J. Pure Appl. Algebra 225 (2021), no. 9, 106642.[DIJ] L. Demonet, O. Iyama, G. Jasso, $\tau$-tilting finite algebras, bricks, and g-vectors, Int. Math. Res. Not. IMRN 3, 852--892 (2019).

[DIRRT] L. Demonet, O. Iyama, N. Reading, I. Reiten, H. Thomas,

*Lattice theory of torsion classes*, arXiv:1711.01785.[E] H. Enomoto,

*Computing various objects of an algebra from the poset of torsion classes*, in preparation.[ES] H. Enomoto, A. Sakai,

*ICE-closed subcategories and wide $\tau$-tilting modules*, to appear in Math. Z.

SageMath version 9.x or later (since this code is based on Python 3)

This module mainly consists of the following.

a class for lattices of torsion classes over $\tau$-tilting fintie artin algebras, together with various methods computing objects naturally arising in the representation theory of algebras.
This is a subclass of a SageMath class `FiniteLatticePoset`

.

a function to create an instance of `FiniteTorsLattice`

. You'll always use this function to use this module.

- Convention
- How it works
- Usage: How to use this module
- Functions: fuctions defined in this module:

Function Name | Description |
---|---|

myshow | A variant of show method, which looks nicer for the Hasse diagram of a poset. |

TorsLattice | Construct a lattice of torsion classes from various forms of input data |

- A class
`FiniteTorsLattice`

and its methods - class FiniteTorsLattice
- Working example: gives two examples which are used throughout this manual
- Basic Methods

Method Name | Description |
---|---|

zero | Return the smallest torsion class $0$ |

whole | Return the largest torsion class, i.e. the whole abelian category |

all_itvs | Return the set of all intervals in the torsion poset |

simples | Return the set of simple torsion classes |

all_bricks | Return the set of all bricks represented by join-irreducibles |

kappa | Return the (extended) kappa map of an element |

bricks_in_tors | Return the set of bricks contained in a torsion class |

bricks_in_torf | Return the set of bricks contained in a torsion-free class $T^\perp$ |

bricks | Return the set of bricks in the heart of an interval of torsion classes |

label | Return the brick label of an Hasse arrow in the lattice of torsion classes |

plus | Return the join of all Hasse arrows ending at `U` |

minus | Return the meet of all Hasse arrows starting at `T` |

Method Name | Description |
---|---|

is_wide_itv | Return `True` if `itv` is a wide interval, and `False` otherwise |

is_ice_itv | Return `True` if `itv` is an ICE interval, and `False` otherwise |

is_ike_itv | Return `True` if `itv` is an IKE interval, and `False` otherwise |

itv_lequal | Return whether the heart of `itv1` is contained in that of `itv2` |

Method Name | Description |
---|---|

wide_simples | Return the set of simple objects in a wide subcategory corresponding to `itv` |

wide_lequal | Compare two wide subcategories corresponding to two torsion classes |

wide_lattice | Return the lattice of wide subcategories |

ice_lattice | Return the lattice of ICE-closed subcategories |

ike_lattice | Return the lattice of IKE-closed subcategories |

heart_poset | Return the poset of torsion hearts ordered by inclusion |

Method Name | Description |
---|---|

indec_tau_rigid | Return the set of indecomposable $\tau$-rigid modules, represented by join-irreducible torsion classes. |

has_tau_rigid_summand | Return the set of $\tau$-tilting pairs which has `M` as a $\tau$-rigid summand |

has_support_summand | Return the set of $\tau$-tilting pairs which have the projective cover of `S` as a support summand |

projectives | Return the set of indecomposable Ext-projectives of `T` represented by join-irreducibles |

composition_factors | Return the set of composition factors of all modules in `T` |

is_sincere | Return `True` if `T` is a sincere torsion class and `False` otherwise |

tau_rigid_pair_summand | Return the set of indecomposable $\tau$-rigid pairs which are direct summands of `T` |

s_tau_tilt_complex | Return the support $\tau$-tilting simplicial complex of the algebra |

positive_tau_tilt_complex | Return the positive $\tau$-tilting simplicial complex of the algebra |

number_of_projs | Return the number of indecomposable Ext-projective objects in a given subcategory |

- For simplicity, we assume that we consider the lattice of torsion classes over some $\tau$-tilting finite artin $R$-algebra over a commutative artinian ring $R$. An artin algebra is
**$\tau$-tilting finite**if there're only finitely many torsion classes.

Though, all methods except those below $\tau$-tilting theory work also for the lattice of torsion classes of some abelian length category with finitely many torsion classes.

*We don't check that a given lattice is actually the lattice of torsion classes over some artin algebra*, because maybe there's no characterization known. We only require that a given lattice is a finite semi-distributive lattice.**The direction of Hasse arrows in displayed in SageMath is opposite to the representation-threorist's convention**, that is,

in SageMath, an arrow $p \to q$ is displayed if $p$ is covered by $q$, thus $p < q$. However, in the description of functions and methods below, we follow the representation-theorist's convention.

We use the notion of *torsion hearts* and a *bijection between bricks and join-irreducible torsion classes*.
The details will be explained in my ongoing paper [E].

- For two torsion classes $\mathcal{U}$ and $\mathcal{T}$ with $\mathcal{U} \subseteq \mathcal{T}$, the
*heart*of an interval $[\mathcal{U}, \mathcal{T}]$ is defined to be the subcategory

$\mathcal{H}_{[\mathcal{U},\mathcal{T}]} := \mathcal{T} \cap \mathcal{U}^\perp$, where $\mathcal{U}^\perp$ is the torsion-free class corresponding to $\mathcal{U}$. We call a subcategory of an abelian category a *torsion heart* if it is a heart of some interval of torsion classes.

It is known that every

*ICE-closed subcategory*(subcategory closed under taking images, cokernels, and extensions) and every*IKE-closed subcategory*(subcategory closed under taking images, kernels, and extensions) is a torsion heart [ES]. In particular, every wide subcategory is also a torsion heart.There is a lattice-theoretic characterization of intervals of torsion classes whose hearts are wide [AP], ICE-closed, or IKE-closed [ES]. Thus there's a surjective map from these intervals to the poset of wide or ICE-closed subcategories.

On the other hand, a torsion heart can be recovered from the set of bricks contained in it [DIRRT]. Thus, we can construct the poset of torsion hearts (or its subposet such as the poset of wide subcategories) if we can combinatorially model the set of bricks contained in a torsion heart.

This can be achieved by using the bijection between bricks and join-irreducible torsion classes in [DIRRT] and the kappa map in [BTZ].

In this manual, I assume that you are using SageMath notebook (but you can use this module by other ways, e.g. using SageMath shell or importing it in your sage code).

So first load it in the notebook.

In [1]:

```
load("tors_lattice.py")
```

`myshow(poset, label = True, vertex_size = 100, **kwargs)`

¶A variant of `show`

method, which looks nicer for the Hasse diagram of a poset.

Note that **the direction of Hasse arrows in SageMath is opposite to
the representation-threorist's convention**, that is,
there is an arrow $p \to q$ if $p$ is covered by $q$.

INPUT:

`poset`

-- an object which has`show`

method, which we expect to be an instance of a SageMath class`FinitePosets`

`label`

-- a Boolean (default:`True`

), whether to label vertices`vertex_size`

-- the size of vertices (default: 100)`**kwargs`

-- keyword arguments that will passed down to`poset.show()`

, see a SageMath method FinitePoset.show

EXAMPLES:

In [2]:

```
P = posets.PentagonPoset()
myshow(P)
```

In [3]:

```
P = WeylGroup("A3").weak_poset()
myshow(P, label=False)
```

`TorsLattice(data = None, *args, **kwargs)`

¶Construct a lattice of torsion classes from various forms of input data

This raises an error if the constructed lattice is not semidistributive, since the lattice of torsion classes is semidistributive.

INPUT:

`data`

,`*args`

,`**kwargs`

-- data and options that will be passed down to a SageMath function`LatticePoset`

to construct a poset that is also a lattice.

OUTPUT:

An instance of a class `FiniteTorsLattice`

EXAMPLES:

An input can be either poset (or lattice) itself or data from which we can construct a poset (`Poset`

for how to construct posets).

In [4]:

```
tors = TorsLattice(posets.PentagonPoset())
tors
```

Out[4]:

In [5]:

```
TorsLattice(([1,2,3,4,5,6], [[1,2],[1,3],[2,4],[3,5],[4,6],[5,6]]))
```

Out[5]:

In [6]:

```
W = WeylGroup("D4")
tors = TorsLattice(W.weak_poset())
tors
```

Out[6]:

Lattice of torsion classes of some tau-tilting finite algebra having 192 torsion classes (use the .plot() method to plot)

`FiniteTorsLattice`

and its methods¶`FiniteTorsLattice`

¶A subclass of a SageMath class `FiniteLatticePoset`

,
which we regard as the class of lattices of all torsion classes
of an abelian length category.
The argument passed to FiniteTorsLattice is assumed to be
a finite semidistributive lattice.

To construct an instance of `FiniteTorsLattice`

, we use a function `TorsLattice`

.

To illustrate various methods, we'll use the following two lattices:

`tors1`

is the lattice of torsion classes of the path algebra of an $A_2$ quiver.`tors2`

is the lattice of torsion classes of the preprojective algebra of type $A_3$.

In [7]:

```
tors1 = TorsLattice(posets.PentagonPoset())
myshow(tors1)
```

In [8]:

```
W = WeylGroup("A3", prefix = "s")
s = W.simple_reflections()
tors2 = TorsLattice(W.weak_poset())
myshow(tors2)
```

In [9]:

```
tors1.zero()
```

Out[9]:

0

In [10]:

```
tors2.zero() # 1 is the unit element of the Weyl group, hence the bottom element
```

Out[10]:

1

In [11]:

```
tors1.whole()
```

Out[11]:

4

In [12]:

```
tors2.whole()
```

Out[12]:

s1*s2*s3*s1*s2*s1

In [13]:

```
tors1.all_itvs()
```

Out[13]:

{(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 1), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (4, 4)}

`simples(self)`

¶Return the set of simple torsion classes.

Here a **simple torsion class** is a Serre subcategory which contains
exactly one simple module, or equivalently,
torsion classes from which there are arrows to $0$.
We can use this to represent the list of simple modules.

EXAMPLES:

In [14]:

```
tors1.simples()
```

Out[14]:

{1, 2}

In [15]:

```
tors2.simples()
```

Out[15]:

{s1, s3, s2}

`all_bricks(self)`

¶Return the set of all bricks represented by join-irreducibles

We always use join-irreducible torsion classes to represent bricks by a bijection in [DIRRT].

EXAMPLES:

In [16]:

```
tors1.all_bricks()
```

Out[16]:

{1, 2, 3}

In [17]:

```
len(tors2.all_bricks()) # the number of all bricks
```

Out[17]:

11

`kappa(self, T)`

¶Return the (extended) kappa map of `T`

This is computed as follows: Let $B_1,\dots, B_k$ be brick labels of all arrows starting from $T$. Then $T$ is the join of $T(B_1), \dots, T(B_k)$, where $T(B)$ is the smallest torsion classes containing $B$. The kappa map $\kappa(T)$ is defined to be the intersection of $^\perp B_1, \dots, {}^\perp B_k$. This operation maps the canonical join representation to the canonical meet representation. See [BTZ] for the detail.

INPUT:

`T`

-- an element (torsion class) of`self`

OUTPUT:

an element of `self`

EXAMPLES:

In [18]:

```
{ T: tors1.kappa(T) for T in tors1 }
```

Out[18]:

{0: 4, 1: 3, 2: 1, 3: 2, 4: 0}

`bricks_in_tors(self, T)`

¶Return the set of bricks contained in a torsion class `T`

INPUT:

`T`

-- an element (torsion class) of`self`

OUTPUT:

the frozenset of bricks (represented by join-irreducibles in `self`

)
contained in `T`

EXAMPLES:

In [19]:

```
tors2.bricks_in_tors(tors2(s[1]*s[2]*s[1]))
```

Out[19]:

frozenset({s2*s1, s1, s2, s1*s2})

`bricks_in_torf(self, T)`

¶Return the set of bricks contained in a torsion-free class $T^\perp$

INPUT:

`T`

-- an element (torsion class) of`self`

OUTPUT:

the frozenset of bricks (represented by join-irreducibles in `self`

)
contained in the torsion-free class corresponding to `T`

,
i.e. $T^\perp$

EXAMPLES:

In [20]:

```
tors2.bricks_in_torf(s[1]*s[2]*s[3])
```

Out[20]:

frozenset({s3, s2, s2*s3, s3*s2})

`bricks(self, itv, *, check = True)`

¶Return the set of bricks in the heart of an interval of torsion classes

For two torsion classes $U,T$ with $U \subseteq T$, its heart is $T \cap U^\perp$ (see [ES]).

INPUT:

`itv`

-- a pair (tuple) of torsion classes`check`

-- a Boolean (default:`True`

), whether to check`itv`

is actually an interval

OUTPUT:

the frozenset of bricks (represented by join-irreducibles) contained in the heart of the given interval

EXAMPLES:

In [21]:

```
tors1.bricks((2,4))
```

Out[21]:

frozenset({1, 3})

`label(self, itv, *, check = True)`

¶Return the brick label of an Hasse arrow in the lattice of torsion classes

For a Hasse arrow $T \to U$, its label is a unique brick contained in $T \cap U^\perp$ [DIRRT].

INPUT:

`itv`

-- a pair (tuple) of torsion classes (U,T), which we expect that U is covered by T`check`

-- a Boolean (default:`True`

), whether to check`itv`

actually gives a covering relation

EXAMPLES:

The following are the Hasse quiver of `tors1`

and `tors2`

together with its brick (join-irreducible) labels

In [22]:

```
myshow(tors1, cover_labels=lambda U,T: tors1.label((U,T)))
```

In [23]:

```
myshow(tors2, cover_labels=lambda U,T: tors2.label((U,T)))
```

`plus(self, U)`

¶Return the join of all Hasse arrows ending at `U`

For a torsion class $U$, its plus $U^{+}$ satisfies that $[U,U^{+}]$ is a wide interval which is the largest wide interval of the form $[U,T]$.

INPUT:

`U`

-- an element (torsion class) of`self`

EXAMPLES:

In [24]:

```
tors2.plus(s[1])
```

Out[24]:

s1*s2*s3*s2

In [25]:

```
tors2.is_wide_itv((s[1], s[1]*s[2]*s[3]*s[2]))
```

Out[25]:

True

`minus(self, T)`

¶Return the meet of all Hasse arrows starting at `T`

For a torsion class $T$, its minus $T^{-}$ satisfies that $[T^{-},T]$ is a wide interval which is the largest wide interval of the form $[U,T]$.

INPUT:

`T`

-- an element (torsion class) of`self`

EXAMPLES:

In [26]:

```
tors2.minus(tors2.whole())
```

Out[26]:

1

`is_wide_itv(self, itv, *, check = True)`

¶Return `True`

if `itv`

is a wide interval, and `False`

otherwise

An interval $[U,T]$ is a wide interval if its heart $T \cap U^\perp$ is a wide subcategory. This method uses a characterization of wide intervals given in [AP].

INPUT:

`itv`

-- a pair (tuple) of torsion classes, which is expected to be an interval`check`

-- a Boolean (default:`True`

), whether to check`itv`

is actually an interval

EXAMPLES:

In [27]:

```
tors1.is_wide_itv((2,3))
```

Out[27]:

True

`is_ice_itv(self, itv, *, check = True)`

¶Return `True`

if `itv`

is an ICE interval, and `False`

otherwise

An interval $[U,T]$ is a wide interval if its heart $T \cap U^\perp$ is an ICE-closed subcategory, that is, closed under taking images, cokernels, and extensions. This method uses a characterization of ICE intervals given in [ES].

INPUT:

`itv`

-- a pair (tuple) of torsion classes, which is expected to be an interval`check`

-- a Boolean (default:`True`

), whether to check`itv`

is actually an interval

EXAMPLES:

In [28]:

```
tors2.is_ice_itv((s[2]*s[1],s[2]*s[1]*s[2]*s[3]))
```

Out[28]:

True

`is_ike_itv(self, itv, *, check = True)`

¶Return `True`

if `itv`

is an IKE interval, and `False`

otherwise

An interval $[U,T]$ is a wide interval if its heart
$T \cap U^\perp$ is an IKE-closed subcategory, that is,
closed under taking images, kernels, and extensions.
This function is just a dual of :func:`is_ice_itv`

.

INPUT:

`itv`

-- a pair (tuple) of torsion classes, which is expected to be an interval`check`

-- a Boolean (default:`True`

), whether to check`itv`

is actually an interval

EXAMPLES:

In [29]:

```
tors1.is_ike_itv((2,4))
```

Out[29]:

True

`itv_lequal(self, itv1, itv2)`

¶Return whether the heart of `itv1`

is contained in that of `itv2`

The heart of an interval $[U,T]$ is a subcategory $T \cap U^\perp$. By [DIRRT], the heart is recovered from bricks contained in it, hence this function compare the sets of bricks in two hearts.

INPUT:

`itv1`

,`itv2`

-- pairs (tuples) of torsion classes, which are assumed to be intervals

OUTPUT:

`True`

if the heart of `itv1`

is contained in that of `itv2`

,
and `False`

otherwise.

EXAMPLES:

In [30]:

```
tors1.itv_lequal((2,3),(0,3))
```

Out[30]:

True

`wide_simples(self, itv)`

¶Return the set of simple objects in a wide subcategory corresponding to `itv`

INPUT:

`itv`

-- a pair (tuple) of torsion class, which we assume is a wide interval

OUTPUT:

the set of simple objects (bricks represented by join-irreducibles) of a wide subcategory which is the heart of `itv`

EXAMPLES:

In [31]:

```
tors1.wide_simples((2,3))
```

Out[31]:

{3}

In [32]:

```
tors2.wide_simples((s[2]*s[1], tors2.plus(s[2]*s[1])))
```

Out[32]:

{s1, s2*s3}

`wide_lequal(self, U, T)`

¶Compare two wide subcategories corresponding to two torsion classes

If there are only finitely many torsion classes, then there is a bijection between the set of torsion classes and the set of wide subcategories by Marks-Stovicek for finite-dimensional algebras and [E] for an abelian length category, see also [AP]. Write $W_L(T)$ for the wide subcategory corresponding to $T$, which is a filtration closure of the brick labels of all Hasse arrows starting at $T$. Then the smallest torsion class containing $W_L(T)$ is $T$. This method returns whether $W_L(U) \subseteq W_L(T)$.

INPUT:

`U`

,`T`

-- elements of`self`

(torsion classes)

OUTPUT:

`True`

if $W_L(U)$ is contained in $W_L(T)$, and `False`

otherwise

REFERENCES:

[MS] F. Marks, J. Stovicek, Torsion classes, wide subcategories and localisations, Bull. London Math. Soc. 49 (2017), Issue 3, 405–416.

[E] H. Enomoto, Monobrick, a uniform approach to torsion-free classes and wide subcategories, arXiv:2005.01626.

EXAMPLES:

In [33]:

```
tors1.wide_lequal(1,4)
```

Out[33]:

True

`wide_lattice(self)`

¶Return the lattice of wide subcategories

The underlying set of this lattice is the same as `self`

, and
its partial order is given by `wide_lequal`

.

OUTPUT:

an instance of a SageMath class `FiniteLatticePoset`

EXAMPLES:

In [34]:

```
tors1.wide_lattice()
```

Out[34]:

In [35]:

```
myshow(tors2.wide_lattice(), label = False)
```