The Cyclically Resolvable Steiner Triple Systems of Order 57

Abstract

A resolution of a Steiner triple system of order v (STS(v)) is point-cyclic if it has an automorphism permuting the points in one cycle. An STS(v) is cyclically resolvable if it has at least one point-cyclic resolution. Cyclically resolvable STS(v)s have important applications in Coding Theory. They have been classified up to $v=45$ and before the present work $v=57$ was the first open case. There are 2,353,310 cyclic STS(57)s. We establish that 155,966 of them are cyclically resolvable yielding 3,638,984 point-cyclic resolutions which we classify with respect to their automorphism groups and to the availability of some configurations.

1. Introduction

Definition 1.

A Steiner triple system of order v (STS(v)) is a pair $D=(V,B)$ where V is a set of v elements called points and B a family of 3-element subsets (triples) of V called blocks, such that each pair of elements of V is contained in exactly one block of B.

An STS(v) has $b=v(v-1)/6$ blocks and each of its points is in $r=(v-1)/2$ blocks. Its incidence matrix has v rows and b columns and the element in the i-th row and j-th column is 1 if point i is in block j, or 0 otherwise. An STS(v) is a 2-$(v,3,1)$ block design. That is why we will further talk either of STS(57)s, or of 2-$(57,3,1)$ designs. Two STS(v)s are isomorphic if there is a bijection of the point sets such that blocks are mapped to blocks. An automorphism of an STS(v) is an isomorphism to itself. All the automorphisms of an STS(v) form its full automorphism group.

A parallel class of an STS(v) is a set of $v/3$ blocks, such that each point is in exactly one block. A resolution of an STS(v) is a partition of the collection of blocks to parallel classes. Two resolutions R and $R^{\prime }$ are isomorphic if there exists an automorphism of the underlying STS(v) which maps each parallel class of R to a parallel class of $R^{\prime }$. An automorphism of the resolution R is an automorphism of the STS(v) which maps each parallel class of R to a parallel class of R. An STS(v) together with a resolution of its blocks is called a Kirkman triple system (KTS(v)). For the basic knowledge on STS(v)s and KTS(v)s refer, for instance, to [1,2]. KTS(v)s are related to error correcting codes in many different ways [3]. It is well known that a KTS(v) is equivalent to an optimal ${(r,v,r-1)}_{v/3}$ equidistant code (length r, v codewords, distance $r-1$, alphabet of $v/3$ elements) [4].

An STS(v) is cyclic if it has an automorphism of order v permuting its points in one cycle. A cyclic STS(v) corresponds to a $(v,3,1)$ cyclic difference family. A resolution is point-cyclic if it has an automorphism permuting the points in one cycle. An STS(v) is resolvable if it has at least one resolution, and it is cyclically resolvable if at least one of its resolutions is point-cyclic.

Example 1.

A cyclic STS(15) is presented in Figure 1. It is invariant under an automorphism of order 15 which permutes the points in one cycle. It generates a cyclic group of order 15 which partitions the blocks to three orbits, namely one short orbit of length 5 and two full orbits of length 15. The full automorphism group of this design is of order 20,160. One of its resolutions is presented in the figure too. It has seven parallel classes, the short block orbit being one of them. This resolution is invariant under an automorphism group of order 168 which is transitive on the parallel classes, but it is not invariant under the cyclic group of order 15 and is therefore not point-cyclic.

The incidence matrix of an STS(v) can be used as a $v\times b$ parity-check matrix of a binary ($3,r$)-regular Low-Density Parity-Check (LDPC) code with v parity-check equations, b codeword bits, row weight r and column weight 3 [5]. If the STS(v) is cyclic, the parity-check matrix is quasi-cyclic (contains circulant submatrices) and therefore allows linear-complexity encoding with simple feedback shift registers [6,7,8]. KTS(v)s are useful when the row weight of such an LDPC code has to be reduced by removing some columns of the parity-check matrix in such a way that the same number of ones are cut off from each row (true if one or several parallel classes are removed) to obtain a lower rate code without changing the other code properties [5,6,9,10]. If the KTS(v) is point-cyclic, fast encoding might be possible too by using the quasi-cyclic structure of the remaining matrix.

A KTS(v) exists if and only if $v\equiv 3$ (mod $6)$, $v\ge 3$ [11]. KTS(v)s are classified up to $v=15$ [12,13]. The full classification of KTS(21)s is out of reach now. One of the most recent results on KTS(21)s presents over 13 million KTS(21)s with subsystems STS(7)s and STS(9)s [14]. Constructions of KTS(v)s for $v\ge 21$ have been considered by many authors [14,15,16,17,18,19,20,21,22,23]. General constructions of point-cyclic KTS(v)s are considered in [24,25] and point-cyclic KTS(v)s with small parameters have been classified up to $v=45$ (

Table 1. Point-cyclic KTS(v)s with small parameters.

v	15	21	27	33	39	45	57
cyclic STS(v)s	2	7	8	84	798	11,616	2,353,310
cycl. resolvable STS(v)s	0	2	2	0	292	600	155,966
point-cyclic KTS(v)s	0	2 [17]	4 [15]	0 [23]	528 [17]	2128 [22]	3,638,984

). Before the present work $v=57$ was the smallest open case. The big number of cyclic STS(v)s and possible parallel classes make it much more difficult to consider $v=57$ than any smaller v. The present paper solves this problem (Table 1).

A KTS(57) with sub-STS(27) can be obtained from the infinite class of Dukes and Lamken of KTS($2u+3$) with sub-STS(u) [16]. The existence of a KTS(57) with sub-KTS(15) is proved in [20]. There are 2,353,310 cyclic STS(57)s [2,26]. Using them we construct all point-cyclic KTS(57)s and study their automorphism groups and some important configurations. Our investigation is computer-aided. We use two different construction algorithms implemented respectively by the two authors in C++.

The paper consists of 5 sections. The action of the cyclic automorphism group of order v on a point-cyclic resolution of an STS(57) is considered in Section 2 and the construction methods are explained in Section 3. Section 4 presents the main results, and a discussion on their impact follows in Section 5.

2. The Action of the Automorphism Group of a Cyclic STS(57)

2.1. The Full Automorphism Groups of the Cyclic STS(57)s

We have in advance all the 2,353,310 cyclic STS(57)s [27] and first find their automorphism groups (

Table 2. The number of automorphisms of the cyclic STS(57)s.

Automorphisms	57	114	171	342	513	1026	1083	6498	19,494	All
STS(57)s	2,351,358	74	1834	33	4	3	1	2	1	2,353,310

). Most of the groups are easy to obtain by our own software written in C++ 14.20 but the calculations were too slow on four of the designs (three with 513 automorphisms and one with 1026). That is why to find their automorphisms we used the software described in [28].

All full automorphism groups contain a subgroup (we denote it $G_{57}$) isomorphic to the cyclic group $C_{57}$ of order 57, namely $G_{57}=〈g〉$, where $g=(0,1,\dots ,56)$.

2.2. Block Orbits Under $G_{57}$

A point-cyclic resolution must be invariant under all subgroups of $G_{57}$, namely under the subgroup $G_3=〈g^{19}〉$ of order 3, and the subgroup $G_{19}=〈g^3〉$ of order 19. Their action on the blocks of an STS(57) is presented in

Table 3. Block orbits of a cyclic STS(57) under $G_{57}$ and its subgroups.

Length	1	3	19	57
$G_3$	19	171
$G_{19}$			28
$G_{57}$			1	9

. An STS(57) has 532 blocks. Under $G_{57}$ there are 9 full block orbits of length 57 and one short block orbit of length 19 which is a parallel class. Under the action of $G_{19}$ there are 28 block orbits of length 19. One of them is the short block orbit under $G_{57}$. Under the action of $G_3$ there are 19 block orbits of length 1 and 171 of length 3. The 19 blocks which $G_3$ fixes are the blocks of the short block orbit under $G_{57}$.

2.3. Point-Cyclic Resolutions of STS(57)s and Their Parallel Class Orbits Under $G_{57}$

According to Mishima and Jimbo [29] there are three types of point-cyclic KTS(v)s:

• $T_1$—the short block orbit under $G_v$ is a parallel class of the resolution;
• $T_2$—each block from the short block orbit is in a different parallel class of the resolution;
• $T_3$—the resolution has parallel classes with more than one block from the short block orbit.

Lemma 1.

Under $G_{19}$ the cyclic STS(57)s can have at most 19 block orbits which are parallel classes.

Proof. 

$G_{19}$ is generated by $g^3$ which acts on the points as

$$(0,3,6,\dots ,51,54)(1,4,7,\dots ,52,55)(2,5,8,\dots ,53,56),$$

i.e., under $G_{19}$ there are three point orbits $o_1=\{0,3,6,\dots ,51,54\}$, $o_2=\{1,4,7,\dots ,52,55\}$, and $o_3=\{2,5,8,\dots ,53,56\}$. If a block B of the STS(57) has two points a and b from one and the same orbit $o_i$, there is an automorphism from $G_{19}$ mapping a to b and B to $B^{\prime }$. Therefore the point b is in two blocks B and $B^{\prime }$ of the corresponding block orbit and that is why this block orbit is not a parallel class. If a block orbit under $G_{19}$ is a parallel class, all its blocks contain one point from each point orbit under $G_{19}$.

In each block orbit which is a parallel class there is a block containing point 0, a point a from $o_2$, and a point b from $o_3$. There are 19 different ways to choose the point a from $o_2$. Since the pair of points $(0,a)$ should be in exactly one block of the Steiner triple system, there can be at most 19 blocks containing point 0 and a point a from $o_2$ and therefore there can be not more than 19 block orbits under $G_{19}$ which are parallel classes.    □

Theorem 1.

All the point-cyclic resolutions of a cyclic STS(57) are of type $T_2$ and under $G_{57}$ their parallel classes are in 1 orbit of length 19 and 3 orbits of length 3.

Proof. 

The number of parallel classes is 28. That is why a class orbit of length 57 is not possible, class orbits should be of lengths 1 (the classes are fixed by $G_{57}$), 3 (the classes are fixed by $G_{19}$) or 19 (the classes are fixed by $G_3$).

There is only one parallel class which is fixed by $G_{57}$, namely the short block orbit. That is why there can be at most one parallel class orbit of length 1. Therefore there are only two possibilities for the parallel class orbits of a point-cyclic KTS(57), namely either 9 class orbits of length 3 and one of length 1, or 3 class orbits of length 3 and one of length 19.

A resolution of type $T_1$ should consist of one class orbit of length 1 and nine class orbits of length 3. In this case $G_{19}$ should fix each parallel class, namely each parallel class should consist of the blocks of one block orbit under $G_{19}$, and therefore all the 28 block orbits under $G_{19}$ should be parallel classes. That is why by Lemma 1 a resolution of type $T_1$ is not possible.

A resolution of type $T_2$ or $T_3$ should consist of one class orbit of length 19 and three class orbits of length 3. In this case $G_3$ should fix the parallel classes from the orbit of length 19. Since a parallel class has 19 blocks, $G_3$ can only fix it if it contains at least one block which is fixed by $G_3$. Since $G_3$ fixes exactly 19 blocks (the blocks of the short orbit) each class of the class orbit of length 19 should contain exactly one of the 19 blocks of the short block orbit. Therefore all point-cyclic resolutions of STS(57)s are of type $T_2$.    □

Corollary 1.

A cyclically resolvable STS(57) has at least 10 (out of all 28) block orbits under $G_{19}$ which are parallel classes.

Proof. 

$G_{19}$ fixes the short block orbit under $G_{57}$. By Theorem 1 the blocks of the short orbit are in the parallel classes of the class orbit of length 19 of a point-cyclic resolution. The remaining 9 parallel classes make three class orbits of length 3, so $G_{19}$ fixes these 9 parallel classes too. That is why at least $1+3.3=10$ block orbits under $G_{19}$ should be parallel classes.    □

3. Construction

To double-check the results, we obtain them in parallel by two different algorithms. For each design we start with sorting its blocks in a lexicographic order defined by the points they contain. We further work with the successive numbers of the blocks in the sorted array.

The first algorithm ($A_1$) uses substantially the results from Section 2.3. We first construct the block orbits under $G_{19}$ and establish that there are 368,486, 1,828,784 and 156,040 cyclic STS(57)s with respectively 1, 7, and 13 block orbits under $G_{19}$ which are parallel classes. By Corollary 1 we further test for cyclic resolvability only the 156,040 designs that have 13 block orbits under $G_{19}$ which are parallel classes. Their full automorphism groups are presented in

Table 4. The number of automorphisms of the cyclic $STS\left(57\right)$ with 13 parallel classes that are block orbits under $G_{19}$.

Automorphisms	57	114	171	342	1026	1083	6498	19,494	All
STS(57)	154,894	46	1062	32	2	1	2	1	156,040

. It further turns out that only 74 of the 156,040 designs are not cyclically resolvable.

$A_1$ constructs only resolutions with the structure from Theorem 1. We denote by $P_{19}$ the lexicographically smallest parallel class (base class) from the class orbit of length 19 and by $P_{3_1}$, $P_{3_2}$, and $P_{3_3}$ the lexicographically smallest parallel classes (base classes) from the three class orbits of length 3. We shall illustrate the construction by several code segments. The first of them presents the function PCres57 in which ReadDes reads each cyclic STS(57) and initializes the variables that will be used further.

The block orbits under the subgroups of $G_{57}$ are found by Orb19PCEnough. This function returns true if at least 10 of the orbits under $G_{19}$ are parallel classes and the computation goes on only for the designs for which this is true. This way using Corollary 1 we consider a number of designs which is 16 times smaller than the initial one. Since Orb19PCEnough is very fast, this practically reduces the computation time about 16 times. We start constructing $P_{19}$ by calling PutBlock19 to add the first block of the short block orbit and then P19Constr.

void PCres57(void)
{
 for(int i=1; i<=2353310; i++)
 {
  ReadDes();
  if(Orb19PCEnough()) //true for only 156040 of all 2353310 designs
  {
   PutBlock19(1,1);
   P19Constr(2);
  }
 }
}

The function P19Constr is presented below. It performs exhaustive backtrack search to choose the blocks of $P_{19}$, $P_{3_1}$, $P_{3_2}$, and $P_{3_3}$. If a block is in $P_{19}$, all the blocks from its orbit under $G_3$ are in the class too, and no other block from its orbit under $G_{19}$ is in the class. Two global arrays are used in the function. TakenOrb19 is one-dimensional and TakenOrb19[i] is true if a block from the i-th orbit under $G_{19}$ has already been added to $P_{19}$. Using it we ensure that $P_{19}$ contains at most one block from each block orbit under $G_{19}$. The array O19 is two-dimensional and O19[i][j] is the number of the j-th block from the i-th orbit under $G_{19}$.

Block19OK(j,n) checks if block j is disjoint with the already chosen $n-1$ blocks of $P_{19}$. PutBlock19(j,n) (TakeBlock19(j,n)) adds to (removes from) $P_{19}$ block j and the two blocks from its orbit under $G_3$ and makes the corresponding changes in TakenOrb19. Since not only one, but three blocks are added, P19Constr(n+3) is called next.

void P19Constr(int n) //choose the n-th block of P19
{
 for(int i=1; i<=28; i++)if(!TakenOrb19[i]) //at most 1 block from orbit
 {
  for(int j=1; j<=19; j++) //19 blocks in an orbit
  {
   if(Block19OK(O19[i][j],n))
   {
    PutBlock19(O19[i][j],n);
    if(n==17) //P19 is completed
    {
     //construct classes from class orbits of length 3:
     if(OKP19()) if(NewRes(1)) P3Constr(20);
    }
    else P19Constr(n+3); //choose the n+3rd block of P19
    TakeBlock19(O19[i][j],n);
   }
  }
 }
}

If $n=17$ the class $P_{19}$ is ready after PutBlock19 has added the last three blocks. In this case 19 out of all 28 parallel classes have already been constructed. Then OKP19 checks if the constructed $P_{19}$ contains exactly 4 blocks from orbits under $G_{19}$ which are parallel classes. If this is true, NewRes establishes if the current solution for $P_{19}$ is not equivalent to a previously obtained lexicographically smaller one. If the solution is new, P3Constr(20) is called.

void P3Constr(int nn)
{
 int n=nn;
 for(int i=1; i<=28; i++) if(!TakenOrb19[i])
 {
  if(OKOrb19(i,n))
  {
   PutOrb19(i,n);
   n+=3;
  }
 }
 if(n!=28) ErrorStop();
 WriteRes();
}

P3Constr chooses the remaining base parallel classes $P_{3_1}$, $P_{3_2}$ and $P_{3_3}$ (with class orbits of length 3). Each of them contains the blocks of one orbit under $G_{19}$. That is why having constructed $P_{19}$, the remaining 9 classes of the resolution are defined, i.e. these are the 9 block orbits under $G_{19}$ which do not have blocks in the constructed $P_{19}$. That is why P3Constr uses TakenOrb19 to see which these 9 orbits are, checks once again by OKOrb19 if they are parallel classes and by PutOrb19 adds them to the resolution together with the other two parallel classes of their class orbits and makes changes to TakenOrb19. Finally WriteRes is called to write the resolution in a file. This way the construction of all point-cyclic KTS(57)s is completed in 5 h on a 3.2 GHz Intel-i9 PC.

The second algorithm ($A_2$) constructs one by one the 28 parallel classes of the resolution, without taking in account the results from Section 2.3, but using only the more general fact that a parallel class contains either whole block orbits under $G_3$, or whole block orbits under $G_{19}$. The current parallel class is constructed from orbits under one of these subgroups in all possible ways, and all parallel classes from its class orbit are added to the resolution before the construction of the next parallel class starts. In particular, the construction is organized by the function ResConstr which does not use Corollary 1 to reduce the number of the considered designs. After reading the design, initializing the necessary variables and finding the necessary block orbits, it calls ChooseBlock to look for possible point-cyclic resolutions.

void ResConstr(void)
{
 for(int s=1; s<=2353310; s++)
 {
  ReadDes();
  FindOrbits();
  ChooseBlock(1,1,1);
 }
}

Two global arrays are used in ChooseBlock. TakenBlock is one-dimensional and TakenBlock[i] is true if block i has already been added to the resolution. The array clLen contains all possible lengths of parallel class orbits, namely $clLen\left[1\right]=19$ and $clLen\left[2\right]=3$, and $maxlencl=2$.

void ChooseBlock(int n, int cl, int lencl)
{
 for(int j=1; j<=532; j++) if (!TakenBlock[j]) //all blocks are 532
 {
  if(BlockOK(j, n, cl, clLen[lencl]))
  {
   all=PutBlock(j,n,cl,clLen[lencl]);
   if(all==19) if(NewRes(cl))
   {
    PutClassOrb();
    if(cl+clLen[lencl]-1==28) WriteRes(); //all parallel classes are 28
    else ChooseBlock(1, cl+clLen[lencl], 1);
    TakeClassOrb();
   }
   else ChooseBlock(all+1, cl, lencl);
   TakeBlock(j,n,cl,clLen[lencl]);
  }
 }
 if(n==1) if(lencl<maxlencl) ChooseBlock(1,cl,lencl+1);//next class length
}

ChooseBlock(n,cl,lencl) chooses in all possible ways the n-th block of the $cl$-th parallel class with class orbit of length $clLen\left[lencl\right]$. If $n=1$ and $lencl<maxlencl$ after finishing the search, ChooseBlock(n,cl,lencl+1) is called. BlockOK(j,n,cl,len) checks if block j and the blocks from its orbit under $G_{v/len}$ are mutually disjoint among themselves and disjoint with the already chosen $n-1$ blocks of class $cl$. PutBlock(j,n,cl,len) (TakeBlock(j,n,cl,len)) adds to (removes from) class $cl$ block j and the blocks from its orbit under $G_{v/len}$ and makes the corresponding changes in TakenBlock. PutBlock returns the number of all the constructed blocks of class $cl$ and assigns it to the variable all. If not all the blocks are constructed, ChooseBlock is called to choose the $all+1$st block of the class.

If $all=19$ the class is ready and NewRes checks if this partial solution is not isomorphic to a previously constructed one. If the solution is new, all parallel classes from the class orbit of the last class are added to the solution by PutClassOrb, and ChooseBlock is called to start constructing the next parallel class, or if all parallel classes have been constructed WriteRes is called to write the resolution in a file.

By the algorithm $A_2$ it would take more than a month to complete the job on a PC. That is why we used the high-performance computer Avitohol of the Bulgarian Academy of Sciences (see the acknowledgment), where a parallel implementation of the program ran on 96 cores and completed the job in 12 h.

Advantages and disadvantages of the two algorithms:

• Both algorithms are based on exhaustive backtrack search and therefore their complexity is exponential. This is a serious disadvantage which makes backtrack search usable only for classification of combinatorial structures with relatively small parameters. Such an algorithm can be made applicable for definite parameters by the rejection of isomorphic partial solutions of some sizes, and by the implementation of suitable restrictions which are true for the considered objects and parameters.
• For the rejection of isomorphic solutions a minimality test is used in both algorithms in the function NewRes. This test is applied to some of the partial solutions and rejects partial solutions for which there exists an automorphism of the considered STS(57) that maps the current partial solution to a lexicographically smaller one. The rejection of partial solutions cuts off big branches of the search tree and makes the computation feasible.
• $A_2$ is applied on all the $2,353,310$ STS(57)s, while $A_1$ considers only those 156,040 designs which remain after using Corollary 1 and is therefore much faster.
• $A_2$ tries to construct resolutions of all possible types and structure, not only with the structure from Theorem 1 which is considered by $A_1$. This makes $A_1$ faster too.
• $A_2$ also constructs parallel classes with more than one block which is fixed under $G_3$. By Theorem 1 there are no such parallel classes in a point-cyclic resolution of an STS(57) and $A_1$ does not construct them. This way $A_1$ saves a lot of time, while $A_2$ obtains a lot of partial solutions which are not extendable to point-cyclic resolutions.

Although $A_1$ is much faster, we implemented the more general algorithm $A_2$ too as a partial check of the correctness of the obtained results, and in particular to check that no solutions were lost by possible errors in the theoretical restrictions, or in the C++ implementations of the algorithms. Each author has implemented in C++ one of the two algorithms. The same results were obtained.

4. Results and Open Problems

We construct all point-cyclic KTS(57)s. The number of automorphisms of the cyclically resolvable STS(57)s and of their resolutions is presented in

Table 5. Automorphisms of the cyclically resolvable STS(57)s and their resolutions.

AutD	57	114	171	342	513	1026	1083	6498	19,494	All
STS(57)s	2,351,358	74	1834	33	4	3	1	2	1	2,353,310
cycl. resolvable D	154,857	46	1027	31	0	1	1	2	1	155,966
R with AutR = 57	3,618,667	2342	15,669	508	0	6	117	75	6	3,637,390
R with AutR = 171	0	0	1520	60	0	1	0	11	0	1592
R with AutR = 513	0	0	0	0	0	1	0	0	1	2
All R	3,618,667	2342	17,189	568	0	8	117	86	7	3,638,984

, where the abbreviation D stands for designs (STS(57)s), R for point-cyclic resolution, AutD denotes the number of automorphisms of the designs, and AutR of the resolutions.

It can be seen that less than 7% of all cyclic STS(57)s are cyclically resolvable and most of their resolutions possess no automorphisms except those from the constructive automorphism group $G_{57}$. There are 1592 point-cyclic KTS(57)s with a full automorphism group of order 171 and 2 with a full automorphism group of order 513.

Some of the point-cyclic KTS(57)s with a full automorphism group of order 171 have only two parallel class orbits under their full automorphism group (

Table 6. Parallel class orbits of point-cyclic KTS(57)s with a full automorphism group of order 171.

AutD	171		342		1026	6498	All
parrallel class orbits	2	4	2	4	2	4	-
point-cyclic KTS(57)s	170	1350	36	24	1	11	1592

). In this case there is an automorphism of order three which maps to one-another the parallel class orbits of length 3 under $G_{57}$, and this way these 9 classes form one class orbit under the full automorphism group of the resolution.

Each cyclically resolvable STS(57) has between 1 and 154 resolutions. The distribution of the number of point-cyclic resolutions of an STS(57) is presented in Figure 2. The maximal number 154 of point-cyclic KTS(57)s of one cyclic STS(57) is achieved by an STS(57) with a full automorphism group $G_{57}$. There are $11,857$ STS(57)s with 21 point-cyclic resolutions.

A full m-configuration in an STS(v) is a set of m blocks which cover $m+2$ points. Each point is in at least two blocks. Full configurations on 4 and 5 blocks are unique and also known as the Pasch and the mitre configurations. The absence of these configurations in a cyclically resolvable cyclic STS(v) is a desirable property with respect to coding applications [6,7,10,30].

The minimum distance of an LDPC code is equal to the minimum nonzero number of columns in its parity-check matrix for which a nontrivial linear combination sums to zero (mod 2) [31]. For an LDPC code from an STS(v) the minimum distance constructively is settled to at least 4 (each column has weight 3 and two columns share no more than one point). The 4 blocks of a Pasch configuration sum to zero (mod 2), while the 5 blocks of a mitre configuration do not. In anti-Pasch STS(v)s no four triples are isomorphic to the Pasch configuration. That is why an LDPC code from an anti-Pasch STS(v) has minimum distance at least 6 [5].

In anti-mitre STS(v)s no five triples are isomorphic to the mitre configuration. If an STS(v) is without any Pasch or mitre configuration it is 5-sparse. 5-sparse KTS(v)s are of major importance not only for the constructions of LDPC codes, but for some other applications in Coding Theory too. One of them is the application of KTS(v)s to optimal erasure-resilient codes for large disk arrays [32].

The number of anti-Pasch, anti-mitre and 5-sparse cyclic STS(57)s is presented in [26]. There are 843 5-sparse cyclic STS(57)s [26]. We establish that only 63 of them are cyclically resolvable, one of them has 171, one 342 automorphisms and all the remaining 61 cyclically resolvable 5-sparse STS(57)s have 57 automorphisms. The number of the resolutions of 5-sparse cyclic STS(57)s is presented in

Table 7. 5-sparse cyclic STS(57)s with a given number of point-cyclic resolutions.

KTS(57)	3	8	9	11	15	16	17	18	19	20	21	22	23	24	25	26	27	28	29	32	109	All
STS(57)	1	1	1	1	2	1	2	5	2	12	6	5	2	3	4	3	3	3	3	2	1	63

. All these resolutions possess only $G_{57}$.

All the constructed in this paper point-cyclic resolutions are available online at http://www.moi.math.bas.bg/moiuser/~stela/SRSTS(57).htm (accessed on 6 January 2025). They can be useful both in possible applications, as well as in future research on the topic.

The classification of the point-cyclic resolutions of STS(63)s is the next open problem, which at the moment is very difficult to attack by our methods because

• The nonisomorphic cyclic STS(63)s are 21 times more than the cyclic STS(57)s.
• The cyclic group of order 57 has two proper subgroups and a parallel class of a point-cyclic resolution is always fixed by one of the two subgroups, while the cyclic group of order 63 has 4 proper subgroups, and this leads to much more complicated considerations.
• The structure of all point-cyclic resolutions of STS(57)s is the same (Theorem 1), while there are several types of point-cyclic resolutions of STS(63)s.
• An STS(63) has 1.1 times more points and 1.22 times more blocks than an STS(57). Such a difference in the considered parameters affects several times the speed of an exponential backtrack search algorithm even if it rejects effectively equivalent partial solutions.

5. Discussion on the Obtained Results

Only a few KTS(57)s were known before the present work, while their number is at least 3,638,984 now. The obtained resolutions have a quasi-cyclic structure that makes them particularly interesting for the construction of LDPC codes with useful structural properties and code rate [5,6,7,9,10]. In addition the anti-Pasch KTS(v)s can produce ($3,r$)-regular LDPC codes with minimum distance at least 6, and those of them which are 5-sparse yield optimal erasure-resilient codes [32]. The availability online of all the obtained resolutions and their automorphisms can be of use for choosing the best of them for certain applications, or for further investigations.

Our computer-aided results have been double-checked by two different algorithms, each of them implemented by one of the two authors. They also comply with previous theoretical results, namely the parameters meet the necessary conditions for the existence of resolutions of type $T_2$ [25] and we obtain resolutions of type $T_2$.

Our investigation shows that:

• There are 155,966 cyclically resolvable STS(57)s with 3,638,984 point-cyclic resolutions.
• The point-cyclic resolutions of STS(57)s have full automorphism groups of orders 57, 171, and 513.
• There are 63 cyclically resolvable 5-sparse STS(57)s with 109 point-cyclic resolutions which are of particular interest for applications in Coding Theory.

We believe this computer-aided investigation will aid further research on these fascinating objects and their applications.