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
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
.
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
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.
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.
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
|
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]
RDS manual