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

# 7 Determining the Isomorphism Class of Projective Planes

### Sections

1. Isomorphisms and Collineations
2. Central Collineations
3. Collineations on Baer Subplanes
4. Invariants for Projective Planes

The methods in this chapter do not deal with relative difference sets. Instead, they help studying projective planes. So if you have a relative difference set, you must first generate the projective plane it defines (if it does).

Projective planes are always assumed to consist of positive integers (as points) and sets of integers (as blocks). The incidence relation is assumed to be the element relation. The blocks of a projective plane must be sets.

The following methods generate a record characterising the projective plane. As most of the functions in this chapter need this data, the record returned by `ElationPrecalc` or `ElationPrecalcSmall` is the recommended representation of projective planes.

- `ElationPrecalc(` blocks`) F`
- `ElationPrecalcSmall(` blocks`) F`

  Given the blocks blocks of a projective plane, `ElationPrecalc(` blocks`)` returns a record conatining

  .points
    the points of the projective plane (immutable)
  .blocks
    the blocks as passed to the function (immutable)
  .jpoint
    a matrix with ij-th entry the point meeting the i-th and the j-th block.
  .jblock
    a matrix with ij-th entry the position of the block connecting the point i to the point j in blocks.

  `ElationPrecalcSmall(` blocks`)` returns a record which does only contain .points, .blocks and .jblock. Hence the name.

  In the following sections, some of the functions have two versions. The versions which have a `Small` appended to it's name do not depend on the data generated by `ElationPrecalc`, but rather on the data structure provided by `ElationPrecalcSmall`. The `Small` versions are generally much slower than the other ones.

- `DualPlane(` blocks`) O`

  For a projective plane given by blocks, `DualPlane(` blocks`)` returns a record containing a set of blocks defining the dual plane and a List image containing the same blocks such that image[p] is the image of the point p under duality. It is not tested, if the design defined by blocks is actually a projective plane.

- `ProjectiveClosureOfPointSet(` points`,` maxsize`,` data`) O`

  Let P be a projective plane given by the record data as returned by `ElationPrecalcSmall`. Let points be a set of points (integers). Then `ProjectiveClosureOfPointSet` returns the projective colsure of points in P (the smallest subplane of P containing the points points). The closure is returned as a list of points. If maxsize ≠ 0, calculations are stopped if the closure is known to have at least maxsize points and data.points is returned. Observe that this is a ``small'' function, in the sense that it does not need the data from `ElationPrecalc` but merely the data generated by `ElationPrecalcSmall`.

  ## 7.1 Isomorphisms and Collineations

  Isomorphisms of projective planes are mappings which take points to points and blocks to blocks and respect incidence. A collineation of a projective plane P is a collineation from P to P (an automorphism).

  As projective planes are assumed to live on the integers, isomorphisms of projective planes are represented by permutations. To test if a permutation on points is actually an isomorphism of projective planes, the following methods can be used.

- `IsIsomorphismOfProjectivePlanes(` perm`,` blocks1`,` blocks2`) O`

  Let blocks1, blocks2 be two sets of blocks of projective planes on the same points. `IsIsomorphismOfProjectivePlanes(` perm`,`blocks1`,`blocks2`)` test if the permutation perm on points defines an isomorphism of the projective planes defined by blocks1 and blocks2.

- `IsCollineationOfProjectivePlane(` perm`,` blocks`) O`
- `IsCollineationOfProjectivePlane(` perm`,` data`) O`

  Let blocks be the blocks of a projective plane and perm a permutation on the points of this plane. `IsCollineationOfProjectivePlane(`perm`,`blocks`)` returns `true`, if perm induces a collineation of the projective plane.

  If data as returned by `ElationPrecalc` is given instead of blocks, the calculation should be faster.

- `IsomorphismProjPlanesByGenerators(` gens1`,` data1`,` gens2`,` data2`) O`
- `IsomorphismProjPlanesByGeneratorsNC(` gens1`,` data1`,` gens2`,` data2`) O`

  Let gens1 be a list of points generating the projective plane defined by data1 and gens2 a list of generating points for data2. Then a permutation is returned representing a mapping from the data1.points to data2.points and mapping the list gens1 to the list gens2. If there is no such mapping which defines an isomorphism of projective planes, `fail` is returned. Note that this is a ``small'' function, in the sense that data1 and data2 are as returned by `ElationPrecalcSmall` rather than by `ElationPrecalc`.

  `IsomorphismProjPlanesByGeneratorsNC` does not checked whether gens1 and gens2 really generate the planes given by data1 and data2.

      # Assume that <blocks> contains a list of lines of a projective plane
      # of order 16
      gap> data:=ElationPrecalc(blocks);;
      gap> Size(ProjectiveClosureOfPointSet([1,2,3,5],16,data));
      4
      gap> Size(ProjectiveClosureOfPointSet([1,2,60,268],16,data));time;
      273
      0
      gap> Size(ProjectiveClosureOfPointSet([1,2,60,268],0,data));time;
      273
      184
      gap> IsomorphismProjPlanesByGenerators([1,2,3,5],data,[1,2,60,268],data);
      fail
      gap> IsomorphismProjPlanesByGenerators([1,2,60,268],data,[1,2,60,268],data);
      ()
      gap> IsomorphismProjPlanesByGenerators([1,2,60,268],data,[1,3,146,268],data);
      (2,3)(5,10)(6,12)(7,9)(8,11)(13,16)(17,249)(18,251)(19,250)( [...] )
      gap> Order(last);
      2

  ## 7.2 Central Collineations

  Let φ be a collineation of a projective plane which fixes one point block-wise (the so-called centre) and one block point-wise (the so-called axis). If the centre is contained in the axis, φ is called elation. Otherwise, φ is called homology. The group of elations with given axis is called translation group of the plane (relative to the chosen axis). A projective plane with transitive translation group is called translation plane. Here transitivity is on the points outside the axis.

- `ElationsByPairs(` centre`,` axis`,` pairs`,` data`) O`
- `ElationsByPairs(` centre`,` axis`,` pairs`,` blocks`) O`
- `ElationsByPairsSmall(` centre`,` axis`,` pairs`,` data`) O`

  Let centre be a point and axis a block of a projective plane defined by blocks (or by data as returned by `ElationPrecalc`). The list pairs must contain pairs of points outside axis. `ElationsByPairs` returns a collineation fixing axis pointwise and centre blockwise (an elation) such that for each pair p of pairs p[1] is mapped on p[2]. If no such elation exists, `fail` is returned.

  `ElationsByPairsSmall` uses data as returned by `ElationPrecalcSmall`

- `AllElationsCentAx(` centre`,` axis`,` data`[, "generators"] ) O`
- `AllElationsCentAx(` centre`,` axis`,` blocks`[, "generators"] ) O`
- `AllElationsCentAxSmall(` centre`,` axis`,` data`[, "generators"] ) O`

  Let centre be a point and axis a block of a projective plane defined by blocks (or by data as returned by `ElationPrecalc`). `AllElationsCentAx` returns a list of all non-trivial elations with centre centre and axis axis. If ``generators'' is set, a list of generators of the translation group is returned.

- `AllElationsAx(` axis`,` data`[, "generators"] ) O`
- `AllElationsAx(` axis`,` blocks`) O`
- `AllElationsAxSmall(` axis`,` data`[, "generators"] ) O`

  Let axis be a block of a projective plane defined by blocks (or by data as returned by `ElationPrecalc`). `AllElationsAx` returns a list of all non-trivial elations with axis axis.

- `IsTranslationPlane(` infline`,` planedata`) O`
- `IsTranslationPlaneSmall(` infline`,` planedata`) O`

  If the group of elations with axis infline is (sharply) transitive on the affine points (the points outside infline), `IsTranslationPlane` returns `true`, otherwise it returns `false`. This is faster than calculating the full translation group if the projective plane is not a translation plane.

- `HomologyByPairSmall(` centre`,` axis`,` pair`,` data`) O`

  `HomologyByPairSmall` returns the homology defined by the pair pair fixing centre blockwise and axis pointwise. The returned permutation fixes axis pointwise and centre linewise and takes pair[1] to pair[2].

- `GroupOfHomologiesSmall(` centre`,` axis`,` data`) O`

  returns the group of homologies with centre centre and axis axis.

  ## 7.3 Collineations on Baer Subplanes

  Let P be a projective plane of order n2. A subplane B of order n of P is called Baer subplane. Baer suplanes are exactly the maximal subplanes of P.

- `InducedCollineation(` baerdata`,` baercoll`,` point`,` image`,` planedata`,` liftingperm`) O`

  If a projective plane contains a Baer subplane, collineations of the subplane may be lifted to the full plane. Here baercoll is a collineation of the subplane given by baerdata (as returned by `ElationPrecalc`. Be careful, as the enumeration for the subplane is not the same as for the whole plane). liftingperm is a permutation on the points of the full pane which converts the enumeration of the subplane to that of the full plane. This means that the image of baerdata.points under liftingperm is a subset of planedata.points. Namely the one representing the Baer plane in the enumeration used for the whole plane. point and image are points outside the Baer plane.

  `InducedCollineation` returns a collineation of the full plane (as a permutation on planedata.points) which takes point to image and acts on the Baer plane as baercoll does.

  Just to make this clear again, baerdata has points [1,...,n2+n+1] and planedata has points [1,...,n4+n2+1]. baercoll lives on baerdata.points (and hence on n2+n+1 points) and point and image live on planedata.points. Anything can happen if you mix something up here.

  ## 7.4 Invariants for Projective Planes

  The functions `NrFanoPlanesAtPoints`, `pRank`, `FingerprintAntiFlag` and `FingerprintProjPlane` calculate invariants for finite projective planes. For more details see RoederDiss and MoorhouseGraphs. The values of some of these invariants are available from the homepages of Moorhouse and Royle for many planes.

- `NrFanoPlanesAtPoints(` points`,` data`) O`

  For a projective plane defined by the blocks data as returned by `ElationPrecalc`, `NrFanoPlanesAtPoints(`points`,`data`)` calculates the so-called Fano invariant. That is, for each point in points, the number of subplanes of order 2 (so-called Fano planes) containing this point is calculated. The method returns a list of pairs of the form [point ,number ] where number is the number of Fano sub-planes in point.

- `NrFanoPlanesAtPointsSmall(` pointlist`,` data`) O`

  Uses data as returned by `ElationPrecalcSmall`. Only use this, if you want to do a quick experiment in a plane of small order and don't like to generate a new set of data with `ElationPrecalc`. The difference between `NrFanoPlanesAtPoints` and `NrFanoPlanesAtPointsSmall` is that the ``small'' version does some operations for lists (like `Intersection`) whereas the ``large'' version does only read matrix entries. This makes quite a difference as for a plane of order n, there are

  |   | n+1 3 |   |  |   | n 2 |   | n

  quadrangles to be tested per point.

- `IncidenceMatrix(` points`,` blocks`) O`
- `IncidenceMatrix(` data`) O`

  returns a matrix I, where the columns are numbered by the blocks and the rows are numbered by points. And I[i][j]=1 if and only if points[i] is incident (contained in) blocks[j].

- `pRank(` blocklist`,` p`) O`
- `pRank(` data`,` p`) O`

  Let I be the incidence matrix of the projective plane given by the list of blocks blocklist or the record data as returned by `ElationPrecalc`. The rank of I·It as a matrix over GF(p) is called p-rank of the projective plane. Here It denotes the transposed matrix.

  As `pRank` calls `IncidenceMatrix`, the list blocklist has to be a list of lists of integers.

- `FingerprintProjPlane(` blocks`) O`
- `FingerprintProjPlane(` data`) O`

  For each anti-flag (p,l) of a projective plane of order n, define an arbitrary but fixed enumeration of the lines through p and the points on l. Say l1,...,ln+1 and p1,...,pn+1 The incidence relation defines a canonical bijection between the li and the pi and hence a permutation on the indices 1,...,n+1. Let σ(p,l) be this permutation.

  Denote the points and lines of the plane by q1,... qn2+n+1 and e1,...,en2+n+1. Define the sign matrix as Aij=sgn(σ(qi,ej)) if (qi,ej) is an anti-flag and =0 if it is a flag. Then the fingerprint is defnied as the multiset of the entries of |AAt|. Here data is a record as returned by `ElationPrecalcSmall`.

- `FingerprintAntiFlag(` point`,` linenr`,` data`) O`

  Let m1,...,mn+1 be the lines containing point and E1,...,En+1 the points on the line given by linenr such that Ei is incident with mi. Now label the points of mi as point =Pi,1,...,Pi,n+1=Ei and the lines of Ei as line =l1,...,li,n+1=mi. For i ≠ j, each Pj,k lies on exactly one line li,kσi,j containing Ei for some permutation σi,j

  Define a matrix A, where Ai,j is the sign of σi,j if i ≠ j and Ai,i=0 for all i. The partial fingerprint is the multiset of entries of |AAt| where At denotes the transposed matrix of A.

  this is a ``small'' function.

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