For t a nonnegative integer and v,k,λ positive integers with t ≤ k ≤ v, a tdesign with parameters t,v,k,λ, or a t(v,k,λ) design, is a binary block design with exactly v points, such that each block has size k and each tsubset of the points is contained in exactly λ blocks.
TDesignLambdas(
t,
v,
k,
lambda )
A t(v,k,λ) design is also an s(v,k,λ_{s}) design
for 0 ≤ s ≤ t, where

Given a nonnegative integer t, and positive integers v, k,
lambda, with t ≤ k ≤ v , this function returns a length
t +1 list whose (s+1)st element is λ_{s} as defined above,
if all the λ_{s} are integers. Otherwise, fail
is returned.
gap> TDesignLambdas(5,24,8,1); [ 759, 253, 77, 21, 5, 1 ]
TDesignLambdaMin(
t,
v,
k )
Given a nonnegative integer t, and positive integers v and k, with
t ≤ k ≤ v , this function returns the minimum positive lambda
such that TDesignLambdas(
t,
v,
k,
lambda )
does not return
fail
.
See TDesignLambdas.
gap> TDesignLambdaMin(5,24,8); 1 gap> TDesignLambdaMin(2,12,4); 3
TDesignIntersectionTriangle(
t,
v,
k,
lambda )
Suppose D is a t(v,k,lambda) design, let i and j be nonnegative integers with i+j ≤ t, and suppose X and Y are disjoint subsets of the points of D, such that X and Y have respective sizes i and j. The (i,j)intersection number is the number of blocks of D that contain X and are disjoint from Y (this number depends only on t, v, k, lambda, i and j).
Given a nonnegative integer t, and positive integers v, k
and lambda, with t ≤ k ≤ v , this function returns the
tdesign intersection triangle, which is a two dimensional array
whose (i+1,j+1)entry is the (i,j)intersection number for
a t(v,k,lambda) design (assuming such a design exists),
such that i,j ≥ 0, i+j ≤ t. This function returns fail
if
TDesignLambdas(
t,
v,
k,
lambda)
does. When lambda =1, then more
information can be obtained using SteinerSystemIntersectionTriangle.
gap> TDesignLambdas(2,12,4,3); [ 33, 11, 3 ] gap> TDesignIntersectionTriangle(2,12,4,3); [ [ 33, 22, 14 ], [ 11, 8 ], [ 3 ] ] gap> TDesignLambdas(2,12,4,2); fail gap> TDesignIntersectionTriangle(2,12,4,2); fail
SteinerSystemIntersectionTriangle(
t,
v,
k )
A Steiner system is a t(v,k,1) design, and in this case it is possible to extend the notion of intersection triangle defined in TDesignIntersectionTriangle.
Suppose D is a t(v,k,1) design, with B a block of D, let i and j be nonnegative integers with i+j ≤ k, and suppose X and Y are disjoint subsets of B, such that X and Y have respective sizes i and j. The (i,j)intersection number is the number of blocks of D that contain X and are disjoint from Y (this number depends only on t, v, k, i and j). Note that when i+j ≤ t, this intersection number is the same as that defined in TDesignIntersectionTriangle for the general tdesign case.
Given a nonnegative integer t, and positive integers v and
k, with t ≤ k ≤ v , this function returns the Steiner
system intersection triangle, which is a two dimensional array whose
(i+1,j+1)entry is the (i,j)intersection number for a t(v,k,1)
design (assuming such a design exists), such that i,j ≥ 0, i+j ≤ k. This function returns fail
if TDesignLambdas(
t,
v,
k,1)
does.
See also TDesignIntersectionTriangle.
gap> SteinerSystemIntersectionTriangle(5,24,8); [ [ 759, 506, 330, 210, 130, 78, 46, 30, 30 ], [ 253, 176, 120, 80, 52, 32, 16, 0 ], [ 77, 56, 40, 28, 20, 16, 16 ], [ 21, 16, 12, 8, 4, 0 ], [ 5, 4, 4, 4, 4 ], [ 1, 0, 0, 0 ], [ 1, 0, 0 ], [ 1, 0 ], [ 1 ] ] gap> TDesignIntersectionTriangle(5,24,8,1); [ [ 759, 506, 330, 210, 130, 78 ], [ 253, 176, 120, 80, 52 ], [ 77, 56, 40, 28 ], [ 21, 16, 12 ], [ 5, 4 ], [ 1 ] ]
TDesignBlockMultiplicityBound(
t,
v,
k,
lambda )
Given a nonnegative integer t, and positive integers v, k and lambda, with t ≤ k ≤ v , this function returns a nonnegative integer which is an upper bound on the multiplicity of any block in any t(v,k,lambda) design (the multiplicity of a block in a block design is the number of times that block occurs in the block list). In particular, if the value 0 is returned, then this implies that a t(v,k,lambda) design does not exist.
Although our bounds are reasonably good, we do not claim that the returned bound m is always achieved; that is, there may not exist a t(v,k,lambda) design having a block with multiplicity m.
See also ResolvableTDesignBlockMultiplicityBound.
gap> TDesignBlockMultiplicityBound(5,16,7,5); 2 gap> TDesignBlockMultiplicityBound(2,36,6,1); 0 gap> TDesignBlockMultiplicityBound(2,36,6,2); 2 gap> TDesignBlockMultiplicityBound(2,15,5,2); 0 gap> TDesignBlockMultiplicityBound(2,15,5,4); 2 gap> TDesignBlockMultiplicityBound(2,11,4,6); 3
ResolvableTDesignBlockMultiplicityBound(
t,
v,
k,
lambda )
A resolution of a block design is a partition of the blocks into subsets, each of which forms a partition of the point set, and a block design is resolvable if it has a resolution.
Given a nonnegative integer t, and positive integers v, k and lambda, with t ≤ k ≤ v , this function returns a nonnegative integer which is an upper bound on the multiplicity of any block in any resolvable t(v,k,lambda) design (the multiplicity of a block in a block design is the number of times that block occurs in the block list). In particular, if the value 0 is returned, then this implies that a resolvable t(v,k,lambda) design does not exist.
Although our bounds are reasonably good, we do not claim that the returned bound m is always achieved; that is, there may not exist a resolvable t(v,k,lambda) design having a block with multiplicity m.
See also TDesignBlockMultiplicityBound.
gap> ResolvableTDesignBlockMultiplicityBound(5,12,6,1); 1 gap> ResolvableTDesignBlockMultiplicityBound(2,21,7,3); 0 gap> TDesignBlockMultiplicityBound(2,21,7,3); 1 gap> ResolvableTDesignBlockMultiplicityBound(2,12,4,3); 1 gap> TDesignBlockMultiplicityBound(2,12,4,3); 2
In CaSo, Cameron and Soicher introduce block intersection polynomials and their applications to the study of block designs. Here we give functions to construct and analyze block intersection polynomials.
BlockIntersectionPolynomial(
x,
m,
lambdavec )
For k a nonnegative integer, define the polynomial
P(x,k)=x(x−1)…(x−k+1). Let s and t be nonnegative
integers, with s ≥ t, and let m_{0},…,m_{s} and
λ_{0},…,λ_{t} be rational numbers. Then the block
intersection polynomial for the sequences [m_{0},…,m_{s}],
[λ_{0},…,λ_{t}] is defined to be

Now suppose x is an indeterminate over the rationals, and m and lambdavec are nonempty lists of rational numbers, such that the length of lambdavec is not greater than that of m. Then this function returns the block intersection polynomial B(x ,m ,lambdavec ).
The importance of a block intersection polynomial is as follows.
Let D=(V,B) be a block design, let S ⊆ V, with s=S,
and for i=0,…,s, suppose that m_{i} is a nonnegative integer
with m_{i} ≤ n_{i}, where n_{i} is the number of blocks intersecting S
in exactly i points. Let t be a nonnegative even integer with t ≤ s, and suppose that, for j=0…,t, we have

For more information on block intersection polynomials and their applications, see CaSo and Soi1.
gap> x:=Indeterminate(Rationals,1); x_1 gap> m:=[0,0,0,0,0,0,0,1];; gap> lambdavec:=TDesignLambdas(6,14,7,4); [ 1716, 858, 396, 165, 60, 18, 4 ] gap> B:=BlockIntersectionPolynomial(x,m,lambdavec); 1715*x_1^610269*x_1^5+34685*x_1^469615*x_1^3+84560*x_1^256196*x_1+15120 gap> Factors(B); [ 1715*x_11715, x_1^51222/245*x_1^4+3733/245*x_1^36212/245*x_1^2+5868/245*x_1432/49 ] gap> Value(B,1); 0
BlockIntersectionPolynomialCheck(
m,
lambdavec)
Suppose m is a list of nonnegative integers, and lambdavec is a list of nonnegative rational numbers, with the length of lambdavec odd and not greater than the length of m.
Then, for x an indeterminate over the rationals, this function
checks whether BlockIntersectionPolynomial(
x,
m,
lambdavec)
is a
polynomial over the integers and has a nonnegative value at each integer.
The function returns true
if this is so; else false
is returned.
See also BlockIntersectionPolynomial.
gap> m:=[0,0,0,0,0,0,0,1];; gap> lambdavec:=TDesignLambdas(6,14,7,4); [ 1716, 858, 396, 165, 60, 18, 4 ] gap> BlockIntersectionPolynomialCheck(m,lambdavec); true gap> m:=[1,0,0,0,0,0,0,1];; gap> BlockIntersectionPolynomialCheck(m,lambdavec); false
[Up] [Previous] [Next] [Index]
design manual