%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % %A construct.tex DESIGN documentation Leonard Soicher % % % \def\DESIGN{\sf DESIGN} \def\GRAPE{\sf GRAPE} \def\nauty{\it nauty} \def\Aut{{\rm Aut}\,} \def\lcm{{\rm lcm}\,} \def\x{\times} \Chapter{Constructing block designs} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \Section{Functions to construct block designs} \>BlockDesign( <v>, <B> ) \>BlockDesign( <v>, <B>, <G> ) Let <v> be a positive integer and <B> a non-empty list of non-empty sorted lists of elements of $\{1,\ldots,<v>\}$. The first version of this function returns the block design with point-set $\{1,\ldots,<v>\}$ and block multiset <C>, where <C> is `SortedList(<B>)'. For the second version of this function, we require <G> to be a group of permutations of $\{1,\ldots,<v>\}$, and the function returns the block design with point-set $\{1,\ldots,<v>\}$ and block multiset <C>, where <C> is the sorted list of the concatenation of the <G>-orbits of the elements of <B>. \beginexample gap> BlockDesign( 2, [[1,2],[1],[1,2]] ); rec( isBlockDesign := true, v := 2, blocks := [ [ 1 ], [ 1, 2 ], [ 1, 2 ] ] ) gap> D:=BlockDesign(7, [[1,2,4]], Group((1,2,3,4,5,6,7))); rec( isBlockDesign := true, v := 7, blocks := [ [ 1, 2, 4 ], [ 1, 3, 7 ], [ 1, 5, 6 ], [ 2, 3, 5 ], [ 2, 6, 7 ], [ 3, 4, 6 ], [ 4, 5, 7 ] ], autSubgroup := Group([ (1,2,3,4,5,6,7) ]) ) gap> AllTDesignLambdas(D); [ 7, 3, 1 ] \endexample \>PGPointFlatBlockDesign( <n>, <q>, <d> ) Let <n> be a non-negative integer, <q> a prime-power, and <d> a non-negative integer less than or equal to <n>. Then this function returns the block design whose points are the (projective) points of the projective space $PG(<n>,<q>)$, and whose blocks are the $<d>$-flats of $PG(<n>,<q>)$, considering a <d>-flat as a set of projective points. Note that the *projective space* $PG(<n>,<q>)$ consists of all the subspaces of the vector space $V(<n>+1,<q>)$, with the *projective points* being the 1-dimensional subspaces and the *$<d>$-flats* being the $(<d>+1)$-dimensional subspaces. \beginexample gap> D:=PGPointFlatBlockDesign(3,2,1);; gap> Print(D,"\n"); rec( isBlockDesign := true, v := 15, pointNames := [ VectorSpace( GF(2), [ [ 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0 ] ] ), VectorSpace( GF(2), [ [ 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2) ] ] ), VectorSpace( GF(2), [ [ 0*Z(2), 0*Z(2), Z(2)^0, Z(2)^0 ] ] ), VectorSpace( GF(2), [ [ 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2) ] ] ), VectorSpace( GF(2), [ [ 0*Z(2), Z(2)^0, 0*Z(2), Z(2)^0 ] ] ), VectorSpace( GF(2), [ [ 0*Z(2), Z(2)^0, Z(2)^0, 0*Z(2) ] ] ), VectorSpace( GF(2), [ [ 0*Z(2), Z(2)^0, Z(2)^0, Z(2)^0 ] ] ), VectorSpace( GF(2), [ [ Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2) ] ] ), VectorSpace( GF(2), [ [ Z(2)^0, 0*Z(2), 0*Z(2), Z(2)^0 ] ] ), VectorSpace( GF(2), [ [ Z(2)^0, 0*Z(2), Z(2)^0, 0*Z(2) ] ] ), VectorSpace( GF(2), [ [ Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0 ] ] ), VectorSpace( GF(2), [ [ Z(2)^0, Z(2)^0, 0*Z(2), 0*Z(2) ] ] ), VectorSpace( GF(2), [ [ Z(2)^0, Z(2)^0, 0*Z(2), Z(2)^0 ] ] ), VectorSpace( GF(2), [ [ Z(2)^0, Z(2)^0, Z(2)^0, 0*Z(2) ] ] ), VectorSpace( GF(2), [ [ Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0 ] ] ) ], blocks := [ [ 1, 2, 3 ], [ 1, 4, 5 ], [ 1, 6, 7 ], [ 1, 8, 9 ], [ 1, 10, 11 ], [ 1, 12, 13 ], [ 1, 14, 15 ], [ 2, 4, 6 ], [ 2, 5, 7 ], [ 2, 8, 10 ], [ 2, 9, 11 ], [ 2, 12, 14 ], [ 2, 13, 15 ], [ 3, 4, 7 ], [ 3, 5, 6 ], [ 3, 8, 11 ], [ 3, 9, 10 ], [ 3, 12, 15 ], [ 3, 13, 14 ], [ 4, 8, 12 ], [ 4, 9, 13 ], [ 4, 10, 14 ], [ 4, 11, 15 ], [ 5, 8, 13 ], [ 5, 9, 12 ], [ 5, 10, 15 ], [ 5, 11, 14 ], [ 6, 8, 14 ], [ 6, 9, 15 ], [ 6, 10, 12 ], [ 6, 11, 13 ], [ 7, 8, 15 ], [ 7, 9, 14 ], [ 7, 10, 13 ], [ 7, 11, 12 ] ] ) gap> Size(AutGroupBlockDesign(D)); 20160 \endexample \>WittDesign( <n> ) Suppose $<n>\in \{9,10,11,12,21,22,23,24\}$. If $<n>=24$ then this function returns the *large Witt design* $W_{24}$, the unique (up to isomorphism) 5-(24,8,1) design. If $<n>=24-i$, where $<i>\in \{1,2,3\}$, then the $i$-fold point-derived design of $W_{24}$ is returned; this is the unique (up to isomorphism) $(5-i)$-$(24-i,8-i,1)$ design. If $<n>=12$ then this function returns the *small Witt design* $W_{12}$, the unique (up to isomorphism) 5-(12,6,1) design. If $<n>=12-i$, where $<i>\in \{1,2,3\}$, then the $i$-fold point-derived design of $W_{12}$ is returned; this is the unique (up to isomorphism) $(5-i)$-$(12-i,6-i,1)$ design. \beginexample gap> W24:=WittDesign(24);; gap> AllTDesignLambdas(W24); [ 759, 253, 77, 21, 5, 1 ] gap> DisplayCompositionSeries(AutomorphismGroup(W24)); G (3 gens, size 244823040) | M(24) 1 (0 gens, size 1) gap> W10:=WittDesign(10);; gap> AllTDesignLambdas(W10); [ 30, 12, 4, 1 ] gap> DisplayCompositionSeries(AutomorphismGroup(W10)); G (4 gens, size 1440) | Z(2) S (4 gens, size 720) | Z(2) S (3 gens, size 360) | A(6) ~ A(1,9) = L(2,9) ~ B(1,9) = O(3,9) ~ C(1,9) = S(2,9) ~ 2A(1,9) = U(2,\ 9) 1 (0 gens, size 1) \endexample \>DualBlockDesign( <D> ) Suppose <D> is a block design for which every point lies on at least one block. Then this function returns the dual of <D>, the block design in which the roles of points and blocks are interchanged, but incidence (including repeated incidence) stays the same. Note that, since the list of blocks of a block design is always sorted, the block list of the dual of the dual of <D> may not be equal to the block list of <D>. \beginexample gap> D:=BlockDesign(4,[[1,3],[2,3,4],[3,4]]);; gap> dualD:=DualBlockDesign(D); rec( isBlockDesign := true, v := 3, blocks := [ [ 1 ], [ 1, 2, 3 ], [ 2 ], [ 2, 3 ] ], pointNames := [ [ 1, 3 ], [ 2, 3, 4 ], [ 3, 4 ] ] ) gap> DualBlockDesign(dualD).blocks; [ [ 1, 2 ], [ 2, 3, 4 ], [ 2, 4 ] ] \endexample \>ComplementBlocksBlockDesign( <D> ) Suppose <D> is a binary incomplete-block design. Then this function returns the block design on the same point-set as <D>, whose blocks are the complements of those of <D> (complemented with respect to the point-set). \beginexample gap> D:=PGPointFlatBlockDesign(2,2,1); rec( isBlockDesign := true, v := 7, pointNames := [ <vector space of dimension 1 over GF(2)>, <vector space of dimension 1 over GF(2)>, <vector space of dimension 1 over GF(2)>, <vector space of dimension 1 over GF(2)>, <vector space of dimension 1 over GF(2)>, <vector space of dimension 1 over GF(2)>, <vector space of dimension 1 over GF(2)> ], blocks := [ [ 1, 2, 3 ], [ 1, 4, 5 ], [ 1, 6, 7 ], [ 2, 4, 6 ], [ 2, 5, 7 ], [ 3, 4, 7 ], [ 3, 5, 6 ] ] ) gap> AllTDesignLambdas(D); [ 7, 3, 1 ] gap> C:=ComplementBlocksBlockDesign(D); rec( isBlockDesign := true, v := 7, blocks := [ [ 1, 2, 4, 7 ], [ 1, 2, 5, 6 ], [ 1, 3, 4, 6 ], [ 1, 3, 5, 7 ], [ 2, 3, 4, 5 ], [ 2, 3, 6, 7 ], [ 4, 5, 6, 7 ] ], pointNames := [ <vector space of dimension 1 over GF(2)>, <vector space of dimension 1 over GF(2)>, <vector space of dimension 1 over GF(2)>, <vector space of dimension 1 over GF(2)>, <vector space of dimension 1 over GF(2)>, <vector space of dimension 1 over GF(2)>, <vector space of dimension 1 over GF(2)> ] ) gap> AllTDesignLambdas(C); [ 7, 4, 2 ] \endexample \>DeletedPointsBlockDesign( <D>, <Y> ) Suppose <D> is a block design and <Y> is a proper subset of the point-set of <D>. Then this function returns the block design $DP$ obtained from <D> by deleting the points in <Y> from the point-set, and from each block. It is an error if the resulting design contains an empty block. The points of $DP$ are relabelled $1,2,...$, preserving the order of the corresponding points of <D>; the point-names of $DP$ (listed in `$DP$.pointNames') are those of these corresponding points of <D>. \beginexample gap> D:=BlockDesigns(rec(v:=11,blockSizes:=[5], > tSubsetStructure:=rec(t:=2,lambdas:=[2])))[1]; rec( isBlockDesign := true, v := 11, blocks := [ [ 1, 2, 3, 4, 5 ], [ 1, 2, 9, 10, 11 ], [ 1, 3, 6, 7, 9 ], [ 1, 4, 7, 8, 10 ], [ 1, 5, 6, 8, 11 ], [ 2, 3, 6, 8, 10 ], [ 2, 4, 6, 7, 11 ], [ 2, 5, 7, 8, 9 ], [ 3, 4, 8, 9, 11 ], [ 3, 5, 7, 10, 11 ], [ 4, 5, 6, 9, 10 ] ], tSubsetStructure := rec( t := 2, lambdas := [ 2 ] ), isBinary := true, isSimple := true, blockSizes := [ 5 ], blockNumbers := [ 11 ], r := 5, autGroup := Group([ (2,4)(3,5)(7,11)(8,9), (1,3)(2,5)(7,9)(10,11), (1,5,3)(6,11,7)(8,10,9), (1,10,5,2,11,3)(4,9,7)(6,8) ]) ) gap> AllTDesignLambdas(D); [ 11, 5, 2 ] gap> DP:=DeletedPointsBlockDesign(D,[5,8]); rec( isBlockDesign := true, v := 9, blocks := [ [ 1, 2, 3, 4 ], [ 1, 2, 7, 8, 9 ], [ 1, 3, 5, 6, 7 ], [ 1, 4, 6, 8 ], [ 1, 5, 9 ], [ 2, 3, 5, 8 ], [ 2, 4, 5, 6, 9 ], [ 2, 6, 7 ], [ 3, 4, 7, 9 ], [ 3, 6, 8, 9 ], [ 4, 5, 7, 8 ] ], pointNames := [ 1, 2, 3, 4, 6, 7, 9, 10, 11 ] ) gap> PairwiseBalancedLambda(DP); 2 \endexample \>DeletedBlocksBlockDesign( <D>, <Y>) Suppose <D> is a block design, and <Y> is a proper sublist of the block-list of <D> (<Y> need not be sorted). Then this function returns the block design obtained from <D> by deleting the blocks in <Y> (counting repeats) from the block-list of <D>. \beginexample gap> D:=BlockDesign(7,[[1,2,4],[1,2,4]],Group((1,2,3,4,5,6,7))); rec( isBlockDesign := true, v := 7, blocks := [ [ 1, 2, 4 ], [ 1, 2, 4 ], [ 1, 3, 7 ], [ 1, 3, 7 ], [ 1, 5, 6 ], [ 1, 5, 6 ], [ 2, 3, 5 ], [ 2, 3, 5 ], [ 2, 6, 7 ], [ 2, 6, 7 ], [ 3, 4, 6 ], [ 3, 4, 6 ], [ 4, 5, 7 ], [ 4, 5, 7 ] ], autSubgroup := Group([ (1,2,3,4,5,6,7) ]) ) gap> DeletedBlocksBlockDesign(D,[[2,3,5],[2,3,5],[4,5,7]]); rec( isBlockDesign := true, v := 7, blocks := [ [ 1, 2, 4 ], [ 1, 2, 4 ], [ 1, 3, 7 ], [ 1, 3, 7 ], [ 1, 5, 6 ], [ 1, 5, 6 ], [ 2, 6, 7 ], [ 2, 6, 7 ], [ 3, 4, 6 ], [ 3, 4, 6 ], [ 4, 5, 7 ] ] ) \endexample \>AddedPointBlockDesign( <D>, <Y> ) \>AddedPointBlockDesign( <D>, <Y>, <pointname> ) Suppose <D> is a block design, and <Y> is a sublist of the block-list of <D> (<Y> need not be sorted). Then this function returns the block design obtained from <D> by adding the new point `<D>.v+1' to the point-set, and adding this new point (once) to each block of <Y> (where repeats count). The optional parameter <pointname> specifies a point-name for the new point. \beginexample gap> D:=BlockDesign(7,[[1,2,4],[1,2,4]],Group((1,2,3,4,5,6,7))); rec( isBlockDesign := true, v := 7, blocks := [ [ 1, 2, 4 ], [ 1, 2, 4 ], [ 1, 3, 7 ], [ 1, 3, 7 ], [ 1, 5, 6 ], [ 1, 5, 6 ], [ 2, 3, 5 ], [ 2, 3, 5 ], [ 2, 6, 7 ], [ 2, 6, 7 ], [ 3, 4, 6 ], [ 3, 4, 6 ], [ 4, 5, 7 ], [ 4, 5, 7 ] ], autSubgroup := Group([ (1,2,3,4,5,6,7) ]) ) gap> AddedPointBlockDesign(D,[[2,3,5],[2,3,5],[4,5,7]],"infinity"); rec( isBlockDesign := true, v := 8, blocks := [ [ 1, 2, 4 ], [ 1, 2, 4 ], [ 1, 3, 7 ], [ 1, 3, 7 ], [ 1, 5, 6 ], [ 1, 5, 6 ], [ 2, 3, 5, 8 ], [ 2, 3, 5, 8 ], [ 2, 6, 7 ], [ 2, 6, 7 ], [ 3, 4, 6 ], [ 3, 4, 6 ], [ 4, 5, 7 ], [ 4, 5, 7, 8 ] ], pointNames := [ 1, 2, 3, 4, 5, 6, 7, "infinity" ] ) \endexample \>AddedBlocksBlockDesign( <D>, <Y> ) Suppose <Y> is a list of multisets of points of the block design <D>. Then this function returns a new block design, whose point-set is that of <D>, and whose block list is that of <D> with the elements of <Y> (including repeats) added. \beginexample gap> D:=BlockDesign(7,[[1,2,4]],Group((1,2,3,4,5,6,7))); rec( isBlockDesign := true, v := 7, blocks := [ [ 1, 2, 4 ], [ 1, 3, 7 ], [ 1, 5, 6 ], [ 2, 3, 5 ], [ 2, 6, 7 ], [ 3, 4, 6 ], [ 4, 5, 7 ] ], autSubgroup := Group([ (1,2,3,4,5,6,7) ]) ) gap> AddedBlocksBlockDesign(D,D.blocks); rec( isBlockDesign := true, v := 7, blocks := [ [ 1, 2, 4 ], [ 1, 2, 4 ], [ 1, 3, 7 ], [ 1, 3, 7 ], [ 1, 5, 6 ], [ 1, 5, 6 ], [ 2, 3, 5 ], [ 2, 3, 5 ], [ 2, 6, 7 ], [ 2, 6, 7 ], [ 3, 4, 6 ], [ 3, 4, 6 ], [ 4, 5, 7 ], [ 4, 5, 7 ] ] ) \endexample \>DerivedBlockDesign( <D>, <x> ) Suppose <D> is a block design, and <x> is a point or block of <D>. Then this function returns the *derived design*\index{derived design} $DD$ of <D>, with respect to <x>. If <x> is a point then $DD$ is the block design whose blocks are those of <D> containing <x>, but with <x> deleted from these blocks, and the points of $DD$ are those which occur in some block of $DD$. If <x> is a block, then the points of $DD$ are the points in <x>, and the blocks of $DD$ are the blocks of <D> other than <x> containing at least one point of <x>, but with all points not in <x> deleted from these blocks. Note that any repeat of <x>, but not <x> itself, is a block of $DD$. It is an error if the resulting block design $DD$ has no blocks or an empty block. The points of $DD$ are relabelled $1,2,...$, preserving the order of the corresponding points of <D>; the point-names of $DD$ (listed in `$DD$.pointNames') are those of these corresponding points of <D>. \beginexample gap> D:=BlockDesigns(rec(v:=11,blockSizes:=[5], > tSubsetStructure:=rec(t:=2,lambdas:=[2])))[1]; rec( isBlockDesign := true, v := 11, blocks := [ [ 1, 2, 3, 4, 5 ], [ 1, 2, 9, 10, 11 ], [ 1, 3, 6, 7, 9 ], [ 1, 4, 7, 8, 10 ], [ 1, 5, 6, 8, 11 ], [ 2, 3, 6, 8, 10 ], [ 2, 4, 6, 7, 11 ], [ 2, 5, 7, 8, 9 ], [ 3, 4, 8, 9, 11 ], [ 3, 5, 7, 10, 11 ], [ 4, 5, 6, 9, 10 ] ], tSubsetStructure := rec( t := 2, lambdas := [ 2 ] ), isBinary := true, isSimple := true, blockSizes := [ 5 ], blockNumbers := [ 11 ], r := 5, autGroup := Group([ (2,4)(3,5)(7,11)(8,9), (1,3)(2,5)(7,9)(10,11), (1,5,3)(6,11,7)(8,10,9), (1,10,5,2,11,3)(4,9,7)(6,8) ]) ) gap> AllTDesignLambdas(D); [ 11, 5, 2 ] gap> DD:=DerivedBlockDesign(D,6); rec( isBlockDesign := true, v := 10, blocks := [ [ 1, 3, 6, 8 ], [ 1, 5, 7, 10 ], [ 2, 3, 7, 9 ], [ 2, 4, 6, 10 ], [ 4, 5, 8, 9 ] ], pointNames := [ 1, 2, 3, 4, 5, 7, 8, 9, 10, 11 ] ) gap> AllTDesignLambdas(DD); [ 5, 2 ] gap> DD:=DerivedBlockDesign(D,D.blocks[6]); rec( isBlockDesign := true, v := 5, blocks := [ [ 1, 2 ], [ 1, 3 ], [ 1, 4 ], [ 1, 5 ], [ 2, 3 ], [ 2, 4 ], [ 2, 5 ], [ 3, 4 ], [ 3, 5 ], [ 4, 5 ] ], pointNames := [ 2, 3, 6, 8, 10 ] ) gap> AllTDesignLambdas(DD); [ 10, 4, 1 ] \endexample \>ResidualBlockDesign( <D>, <x> ) Suppose <D> is a block design, and <x> is a point or block of <D>. Then this function returns the *residual design*\index{residual design} $RD$ of <D>, with respect to <x>. If <x> is a point then $RD$ is the block design whose blocks are those of <D> not containing <x>, and the points of $RD$ are those which occur in some block of $RD$. If <x> is a block, then the points of $RD$ are those of <D> not in <x>, and the blocks of $RD$ are the blocks of <D> (including repeats) containing at least one point not in <x>, but with all points in <x> deleted from these blocks. It is an error if the resulting block design $RD$ has no blocks. The points of $RD$ are relabelled $1,2,...$, preserving the order of the corresponding points of <D>; the point-names of $RD$ (listed in `$RD$.pointNames') are those of these corresponding points of <D>. \beginexample gap> D:=BlockDesigns(rec(v:=11,blockSizes:=[5], > tSubsetStructure:=rec(t:=2,lambdas:=[2])))[1]; rec( isBlockDesign := true, v := 11, blocks := [ [ 1, 2, 3, 4, 5 ], [ 1, 2, 9, 10, 11 ], [ 1, 3, 6, 7, 9 ], [ 1, 4, 7, 8, 10 ], [ 1, 5, 6, 8, 11 ], [ 2, 3, 6, 8, 10 ], [ 2, 4, 6, 7, 11 ], [ 2, 5, 7, 8, 9 ], [ 3, 4, 8, 9, 11 ], [ 3, 5, 7, 10, 11 ], [ 4, 5, 6, 9, 10 ] ], tSubsetStructure := rec( t := 2, lambdas := [ 2 ] ), isBinary := true, isSimple := true, blockSizes := [ 5 ], blockNumbers := [ 11 ], r := 5, autGroup := Group([ (2,4)(3,5)(7,11)(8,9), (1,3)(2,5)(7,9)(10,11), (1,5,3)(6,11,7)(8,10,9), (1,10,5,2,11,3)(4,9,7)(6,8) ]) ) gap> AllTDesignLambdas(D); [ 11, 5, 2 ] gap> RD:=ResidualBlockDesign(D,6); rec( isBlockDesign := true, v := 10, blocks := [ [ 1, 2, 3, 4, 5 ], [ 1, 2, 8, 9, 10 ], [ 1, 4, 6, 7, 9 ], [ 2, 5, 6, 7, 8 ], [ 3, 4, 7, 8, 10 ], [ 3, 5, 6, 9, 10 ] ], pointNames := [ 1, 2, 3, 4, 5, 7, 8, 9, 10, 11 ] ) gap> AllTDesignLambdas(RD); [ 6, 3 ] gap> RD:=ResidualBlockDesign(D,D.blocks[6]); rec( isBlockDesign := true, v := 6, blocks := [ [ 1, 2, 3 ], [ 1, 2, 4 ], [ 1, 3, 6 ], [ 1, 4, 5 ], [ 1, 5, 6 ], [ 2, 3, 5 ], [ 2, 4, 6 ], [ 2, 5, 6 ], [ 3, 4, 5 ], [ 3, 4, 6 ] ], pointNames := [ 1, 4, 5, 7, 9, 11 ] ) gap> AllTDesignLambdas(RD); [ 10, 5, 2 ] \endexample \>TDesignFromTBD( <D>, <t>, <k> ) For $t$ a non-negative integer, $K$ a set of positive integers, and $v,\lambda$ positive integers with $t\le v$, a $t$-*wise balanced design*, or a $t$-$(v,K,\lambda)$ *design*, is a binary block design with exactly $v$ points, such that each block has size in $K$ and each $t$-subset of the points is contained in exactly $\lambda$ blocks. Now let <t> and <k> be positive integers, <D> be a <t>-$(v,K,\lambda)$ design (for some set $K$), and $<t>\le <k>\le k_1$, where exactly $s$ distinct block-sizes $k_1\< \cdots \< k_s$ occur in <D>. Then this function returns the <t>-design $D^{*}=D^{*}(t,k)$ described and studied in \cite{McSo}. The point set of $D^{*}$ is that of <D>, and the block multiset of $D^{*}$ consists of, for each $i=1,\ldots,s$ and each block $B$ of <D> of size $k_i$ (including repeats), exactly $n/{k_i-t \choose k-t}$ copies of every $k$-subset of $B$, where $n:=\lcm({k_i-t \choose k-t}:1\le i\le s)$. It is shown in \cite{McSo} that $D^{*}$ is a $t$-$(v,k,n\lambda)$ design, that $\Aut(D)\subseteq\Aut(D^{*})$, and that if $\lambda=1$ and $t\<k$, then $\Aut(D)=\Aut(D^{*})$. \beginexample gap> D:=BlockDesigns(rec(v:=10, blockSizes:=[3,4], > tSubsetStructure:=rec(t:=2,lambdas:=[1])))[1]; rec( isBlockDesign := true, v := 10, blocks := [ [ 1, 2, 3, 4 ], [ 1, 5, 6, 7 ], [ 1, 8, 9, 10 ], [ 2, 5, 10 ], [ 2, 6, 8 ], [ 2, 7, 9 ], [ 3, 5, 9 ], [ 3, 6, 10 ], [ 3, 7, 8 ], [ 4, 5, 8 ], [ 4, 6, 9 ], [ 4, 7, 10 ] ], tSubsetStructure := rec( t := 2, lambdas := [ 1 ] ), isBinary := true, isSimple := true, blockSizes := [ 3, 4 ], blockNumbers := [ 9, 3 ], autGroup := Group([ (5,6,7)(8,9,10), (2,3)(5,7)(8,10), (2,3,4)(5,7,6)(8,9,10), (2,3,4)(5,9,6,8,7,10), (2,6,9,3,7,10)(4,5,8) ]) ) gap> PairwiseBalancedLambda(D); 1 gap> Dstar:=TDesignFromTBD(D,2,3); rec( isBlockDesign := true, v := 10, blocks := [ [ 1, 2, 3 ], [ 1, 2, 4 ], [ 1, 3, 4 ], [ 1, 5, 6 ], [ 1, 5, 7 ], [ 1, 6, 7 ], [ 1, 8, 9 ], [ 1, 8, 10 ], [ 1, 9, 10 ], [ 2, 3, 4 ], [ 2, 5, 10 ], [ 2, 5, 10 ], [ 2, 6, 8 ], [ 2, 6, 8 ], [ 2, 7, 9 ], [ 2, 7, 9 ], [ 3, 5, 9 ], [ 3, 5, 9 ], [ 3, 6, 10 ], [ 3, 6, 10 ], [ 3, 7, 8 ], [ 3, 7, 8 ], [ 4, 5, 8 ], [ 4, 5, 8 ], [ 4, 6, 9 ], [ 4, 6, 9 ], [ 4, 7, 10 ], [ 4, 7, 10 ], [ 5, 6, 7 ], [ 8, 9, 10 ] ], autGroup := Group([ (5,6,7)(8,9,10), (2,3)(5,7)(8,10), (2,3,4)(5,7,6)(8,9, 10), (2,3,4)(5,9,6,8,7,10), (2,6,9,3,7,10)(4,5,8) ]) ) gap> AllTDesignLambdas(Dstar); [ 30, 9, 2 ] \endexample %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%