[SONATA] 11 Designs

[Up] [Previous] [Index]

# 11 Designs

### Sections

1. Constructing a design
2. Properties of a design
3. Working with the points and blocks of a design

Although the functions described in this section were initially meant to investigate designs generated from nearrings, they can also be applied to other incidence structures. In principal a design is represented as a set of points and a set of blocks, a subset of the powerset of the points, with containment as incidence relation.

## 11.1 Constructing a design

- `DesignFromPointsAndBlocks(` points`,` blocks`)`

  `DesignFromPointsAndBlocks` returns the design with the set of points points and the set of blocks blocks, a subset of the powerset of points.

          gap> points := [1..7];;
          gap> blocks := [[1,2,3],[1,4,5],[1,6,7],[2,4,7],[2,5,6],[3,5,7],
          >                                                          [3,4,6]];;
          gap> D := DesignFromPointsAndBlocks( points, blocks );
          <an incidence structure with 7 points and 7 blocks>

- `DesignFromIncidenceMat( M ) ;`

  `DesignFromIncidenceMat` returns the design with incidence matrix M, The rows of M are labelled by the set of points 1 to v, the columns represent the blocks. If the ( i, j ) entry of the matrix M is 1, then the point i is incident with the j-th block, i.e. the j-th block consists of those points i for which the entry ( i, j ) of M is 1. All other entries have to be 0.

          gap> M := [[1,0,1,1],
          >          [1,1,0,0],
          >          [1,1,1,0]];;
          gap> DesignFromIncidenceMat( M );
          <an incidence structure with 3 points and 4 blocks>

- `DesignFromPlanarNearRing(` N`,` type`)`

  `DesignFromPlanarNearRing` returns a design obtained from the planar nearring N following the constructions of James R. Clay <[>Clay:Nearrings].

  If type = `"*"`, `DesignFromPlanarNearRing` returns the design (N,B*,in) in the notation of J. R. Clay with the elements of N as set of points and {N*cdota+b | a,binN, a not= 0 } as set of blocks. Here N* is the set of elements xinN satisfying xcdotN = N.

  If type = `" "` (blank), `DesignFromPlanarNearRing` returns the design (N,B,in) in the notation of J. R. Clay with the elements of N as set of points and {Ncdota+b | a,binN, a not= 0 } as set of blocks.

          gap> n := LibraryNearRing( GTW9_2, 90 );
          LibraryNearRing(9/2, 90)
          gap> IsPlanarNearRing( n );
          true
          gap> D1 := DesignFromPlanarNearRing( n, "*" );
          <a 2 - ( 9, 4, 3 ) nearring generated design>
          gap> D2 := DesignFromPlanarNearRing( n, " " );
          <a 2 - ( 9, 5, 5 ) nearring generated design>

- `DesignFromFerreroPair(` G`,` phi`,` type`)`

  `DesignFromFerreroPair` returns a design obtained from the group G, and a group of fixed-point-free automorphisms phi acting on G following the constructions of James R. Clay <[>Clay:Nearrings].

  If type = `"*"`, `DesignFromFerreroPair` returns the design (G,B*,in) in the notation of J. R. Clay with the elements of G as set of points and the nonzero orbits of G under phi and their translates by group-elements as set of blocks.

  If type = `" "` (blank), `DesignFromFerreroPair` returns the design (G,B,in) in the notation of J. R. Clay with the elements of G as set of points and the nonzero orbits of G under phi joined with the zero of G and their translates by group-elements as set of blocks.

          gap> aux := FpfAutomorphismGroupsCyclic( [3,3], 4 );
          [ [ [ f1, f2 ] -> [ f1*f2, f1*f2^2 ] ],
            <pc group of size 9 with 2 generators> ]
          gap> f := aux[1][1];
          [ f1, f2 ] -> [ f1*f2, f1*f2^2 ]
          gap> phi := Group( f );
          <group with 1 generators>
          gap> G := aux[2];
          <pc group of size 9 with 2 generators>
          gap> D3 := DesignFromFerreroPair( G, phi, "*" );
          <a 2 - ( 9, 4, 3 ) nearring generated design>
          gap> # D3 is actually isomorphic to D1

- `DesignFromWdNearRing(` N`)`

  `DesignFromWdNearring` returns a design obtained from the weakly divisible nearring N with cyclic additive group of prime power order. Following the constructions of A. Benini, F. Morini and S. Pellegrini, we take the elements of N as set of points and {Ncdota+b | ainC, binN} as set of blocks. Here C is the set of elements ainN such that acdotN = N.

          gap> n := LibraryNearRing( GTW9_1, 202 );
          LibraryNearRing(9/1, 202)
          gap> IsWdNearRing( n );
          true
          gap> DesignFromWdNearRing( n );
          <a 1 - ( 9, 5, 10 ) nearring generated design>

  ## 11.2 Properties of a design

- `PointsOfDesign(` D`)`

  `PointsOfDesign` returns the actual list of points of the design D, not their positions, no matter how the points of the design D may be represented. To get the representation of those points, whose positions in the list of all points are given by the list pointnrs, one can use `PointsOfDesign(` D`){`pointnrs`}`.

          gap> D1;
          <a 2 - ( 9, 4, 3 ) nearring generated design>
          gap> PointsOfDesign( D1 );
          [ (()), ((4,5,6)), ((4,6,5)), ((1,2,3)), ((1,2,3)(4,5,6)),
            ((1,2,3)(4,6,5)), ((1,3,2)), ((1,3,2)(4,5,6)), ((1,3,2)(4,6,5)) ]
          gap> PointsOfDesign( D1 ){[2,4]};
          [ ((4,5,6)), ((1,2,3)) ]
          gap> # returns the points in position 2 and 4

- `BlocksOfDesign(` D`)`

  `BlocksOfDesign` returns the actual list of blocks of the design D, not their positions. Blocks are represented as lists of points. A point is incident with a block if the point is an element of the block. To get the representation of those blocks, whose positions in the list of all blocks are given by the list blocknrs, one can use `BlocksOfDesign(` D`){`blocknrs`}`.

          gap> Length( BlocksOfDesign( D1 ) );
          18
          gap> BlocksOfDesign( D1 ){[3]};
          [ [ ((4,6,5)), (()), ((1,2,3)(4,5,6)), ((1,3,2)(4,5,6)) ] ]
          gap> # returns the block in position 3 as a list of points

- `DesignParameter(` D`)`

  `DesignParameter` returns the set of paramaters t, v, b, r, k, lambda of the design D. Here v is the size of the set of points `PointsOfDesign`, b is the size of the set of blocks `PointsOfDesign`, every point is incident with precisely r blocks, every block is incident with precisely k points, every t distinct points are together incident with precisely lambda blocks.

          gap> DesignParameter( D1 );
          [ 2, 9, 18, 8, 4, 3 ]
          gap> # t = 2, v = 9, b = 18, r = 8, k = 4, lambda = 3

- `IncidenceMat(` D`)`

  `IncidenceMat` returns the incidence matrix of the design D, where the rows are labelled by the positions of the points in `PointsOfDesign`, the columns are labelled by the positions of the blocks in `BlocksOfDesign`. If the point in position i is incident with the block in position j, then the ( i, j ) entry of the matrix `IncidenceMat` is 1, else it is 0.

          gap> M1 := IncidenceMat( D1 );
          [ [ 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1 ],
            [ 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1 ],
            [ 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 ],
            [ 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1 ],
            [ 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1 ],
            [ 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0 ],
            [ 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0 ],
            [ 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0 ],
            [ 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0 ] ]

- `PrintIncidenceMat(` D`)`

  `PrintIncidenceMat` prints only the entries of the incidence matrix `IncidenceMat` of the design without commas. If the point in position i is incident with the block in position j, then there is 1 in the i-th row, j-th column, else there is '.', a dot.

          gap> PrintIncidenceMat( D1 );
          ..1.1.1..1.11..1.1
          1...1..11..1.11..1
          1.1....1.11..1.11.
          1..1.1..1.1.1..1.1
          .11..11...1..11..1
          .1.11.1.1....1.11.
          1..1.11..1.1..1.1.
          .11..1.11..11...1.
          .1.11..1.11.1.1...

- `BlockIntersectionNumbers(` D`)`
- `BlockIntersectionNumbersK(` D`,` blocknr`)`

  In the first form `BlockIntersectionNumbers` returns the list of cardinalities of the intersection of each block with all other blocks of the design D. In the second form `BlockIntersectionNumbers` returns the list of cardinalities of the intersection of the block in position blocknr with all other blocks of the design D.

          gap> BlockIntersectionNumbers( D1, 2 );
          [ 0, 4, 2, 2, 2, 2, 2, 2, 2, 1, 2, 1, 2, 2, 2, 1, 2, 1 ]
          gap> # the second has empty intersection with the first block
          gap> # and intersects all others in at most 2 points

- `IsCircularDesign(` D`)`

  `IsCircularDesign` returns `true` if the design D is circular and `false` otherwise. The design D has to be the result of `DesignFromPlanarNearRing` or `DesignFromFerreroPair`, since `IsCircularDesign` assumes the particular structure of such a nearring-generated design.

  A design D is circular if every two distinct blocks intersect in at most two points.

  `IsCircularDesign` calls the function `BlockIntersectionNumbers`.

          gap> IsCircularDesign( D1 );
          true

  ## 11.3 Working with the points and blocks of a design

- `IsPointIncidentBlock(` D`,` pointnr`,` blocknr`)`

  `IsPointIncidentBlock` returns `true` if the point whose position in the list `PointsOfDesign(` D`)` is given by pointnr is incident with the block whose position in the list `BlocksOfDesign(` D`)` is given by blocknr, that is, the point is contained in the block as an element in a set.

          gap> IsPointIncidentBlock( D1, 3, 1 );
          true
          gap> # point 3 is incident with block 1
          gap> IsPointIncidentBlock( D1, 3, 2 );
          false

- `PointsIncidentBlocks(` D`,` blocknrs`)`

  `PointsIncidentBlocks` returns a list of positions of those points of the design D which are incident with the blocks, whose positions are given in the list blocknrs.

          gap> PointsIncidentBlocks( D1, [1, 4] );
          [ 4, 7 ]
          gap> # block 1 and block 4 are together incident with
          gap> # points 4 and 7

- `BlocksIncidentPoints(` D`,` pointnrs`)`

  `BlocksIncidentPoints` returns a list of positions of the blocks of the design D which are incident with those points, whose positions are given in the list pointnrs.

          gap> BlocksIncidentPoints( D1, [2, 7] );
          [ 1, 12, 15 ]
          gap> # point 2 and point 7 are together incident with
          gap> # blocks 1, 12, 15
          gap> BlocksOfDesign( D1 ){last};
          [ [ ((4,5,6)), ((4,6,5)), ((1,2,3)), ((1,3,2)) ],
            [ ((1,3,2)), ((1,3,2)(4,5,6)), (()), ((4,5,6)) ],
            [ ((1,3,2)(4,6,5)), ((1,3,2)), ((4,5,6)), ((1,2,3)(4,5,6)) ] ]
          gap> # the actual point sets of blocks 1, 12, and 15
          gap> BlocksIncidentPoints( D1, [2, 3, 7] );
          [ 1 ]
          gap> # points 2, 3, 7 are together incident with block 1
          gap> PointsIncidentBlocks( D1, [1] );
          [ 2, 3, 4, 7 ]
          gap> # block 1 is incident with points 2, 3, 4, 7

  [Up] [Previous] [Index]