[Up] [Previous] [Next] [Index]

# 2 Information from block design parameters

## 2.1 Information from \$t\$-design parameters

For t a non-negative integer and v,k,λ positive integers with tkv, a t-design 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 t-subset of the points is contained in exactly λ blocks.

• `TDesignLambdas( `t`, `v`, `k`, `lambda` )`

A t-(v,k,λ) design is also an s-(v,ks) design for 0 ≤ st, where
 λs=λ ⎛⎝ v−st−s ⎞⎠ / ⎛⎝ k−st−s ⎞⎠
.

Given a non-negative integer t, and positive integers v, k, lambda, with tkv , 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 non-negative integer t, and positive integers v and k, with tkv , 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 non-negative integers with i+jt, 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 non-negative integer t, and positive integers v, k and lambda, with tkv , this function returns the t-design 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+jt. 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 non-negative integers with i+jk, 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+jt, this intersection number is the same as that defined in TDesignIntersectionTriangle for the general t-design case.

Given a non-negative integer t, and positive integers v and k, with tkv , 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+jk. This function returns `fail` if `TDesignLambdas(`t`,`v`,`k`,1)` does.

```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 non-negative integer t, and positive integers v, k and lambda, with tkv , this function returns a non-negative 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.

```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 non-negative integer t, and positive integers v, k and lambda, with tkv , this function returns a non-negative 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.

```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
```

## 2.2 Block intersection polynomials

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 non-negative integer, define the polynomial P(x,k)=x(x−1)…(xk+1). Let s and t be non-negative integers, with st, and let m0,…,ms and λ0,…,λt be rational numbers. Then the block intersection polynomial for the sequences [m0,…,ms], [λ0,…,λt] is defined to be
 t∑j=0 ⎛⎝ tj ⎞⎠ P(−x,t−j)[P(s,j)λj− s∑i=j P(i,j)mi],
and is denoted by B(x,[m0,…,ms],[λ0,…,λt])·

Now suppose x is an indeterminate over the rationals, and m and lambdavec are non-empty 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 SV, with s=|S|, and for i=0,…,s, suppose that mi is a non-negative integer with mini, where ni is the number of blocks intersecting S in exactly i points. Let t be a non-negative even integer with ts, and suppose that, for j=0…,t, we have
 λj=1/ ⎛⎝ sj ⎞⎠ ∑T ⊆ S,|T|=j λT
, where λT is the number of blocks of D containing T. Then the block intersection polynomial B(x)=B(x,[m0,…,ms],[λ0,…,λt]) is a polynomial with integer coefficients, and B(n) ≥ 0 for every integer n. (These conditions can be checked using the function BlockIntersectionPolynomialCheck.) In addition, if B(n)=0 for some integer n, then mi=ni for i ∉ {n,n+1,…,n+t−1}.

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^6-10269*x_1^5+34685*x_1^4-69615*x_1^3+84560*x_1^2-56196*x_1+15120
gap> Factors(B);
[ 1715*x_1-1715,
x_1^5-1222/245*x_1^4+3733/245*x_1^3-6212/245*x_1^2+5868/245*x_1-432/49 ]
gap> Value(B,1);
0
```

• `BlockIntersectionPolynomialCheck(`m`, `lambdavec`)`

Suppose m is a list of non-negative integers, and lambdavec is a list of non-negative 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 non-negative value at each integer. The function returns `true` if this is so; else `false` is returned.

```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
March 2019