% This file was created automatically from iso.msk.
% DO NOT EDIT!
\Chapter{Determining the Isomorphism Class of 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 
\beginlist
 \item{.points} the points of the projective plane (immutable)
 \item{.blocks} the blocks as passed to the function (immutable)
 \item{.jpoint} a matrix with $ij$-th entry the point meeting the 
    $i$-th and the $j$-th block.
 \item{.jblock} a matrix with $ij$-th entry the position of the block 
     connecting the point $i$ to the point $j$ in <blocks>.
\endlist

`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>\neq 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'.



%%%%%%%%%%%%%%%%%%%%
\Section{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>. 



\begintt
# 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
\endtt


%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Central Collineations}

Let $\phi$ 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, $\phi$
is called *elation*. Otherwise, $\phi$ 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>.



%%%%%%%%%%%%%%%%%%%%
\Section{Collineations on Baer Subplanes}

Let $P$ be a projective plane of order $n^2$. 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,\dots,n^2+n+1]$
and <planedata> has points $[1,\dots,n^4+n^2+1]$. <baercoll> lives on 
<baerdata.points> (and hence on $n^2+n+1$ points) and <point> and <image> 
live on <planedata.points>. Anything can happen if you mix something up 
here.


%%%%%%%%%%%%%%%%%%%%
\Section{Invariants for Projective Planes}

The functions `NrFanoPlanesAtPoints', `pRank', `FingerprintAntiFlag'
and `FingerprintProjPlane' calculate invariants for finite projective
planes. For more details see \cite{RoederDiss} and
\cite{MoorhouseGraphs}. The values of some of these invariants are
available from the homepages of \cite{Moorhouse} and \cite{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 \choose 3}{n\choose 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.I^t$ as a matrix over
$GF(p)$ is called  <p>-rank of the projective plane. Here $I^t$ 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 $l_1,\dots,l_{n+1}$ and $p_1,\dots,p_{n+1}$
The incidence relation defines a canonical bijection between the $l_i$ and
the $p_i$ and hence a permutation on the indices $1,\dots,n+1$. 
Let $\sigma_{(p,l)}$ be this permutation.

Denote the points and lines of the plane by $q_1,\dots q_{n^2+n+1}$ 
and $e_1,\dots,e_{n^2+n+1}$. 
Define the sign matrix as $A_{ij}=sgn(\sigma_{(q_i,e_j)})$ if $(q_i,e_j)$ 
is an anti-flag and $=0$ if it is a flag.
Then the fingerprint is defnied as the multiset of the entries of $|AA^t|$.
Here <data> is a record as returned by `ElationPrecalcSmall'.


\>FingerprintAntiFlag( <point>, <linenr>, <data> ) O

Let $m_1,\dots,m_{n+1}$ be the lines containing <point> and 
$E_1,\dots,E_{n+1}$ the points on the line given by <linenr> such that
$E_i$ is incident with $m_i$. Now label the points of $m_i$ as 
$<point>=P_{i,1},\dots,P_{i,n+1}=E_i$ and the lines of $E_i$ as
$<line>=l_1,\dots,l_{i,n+1}=m_i$. 
For $i\not = j$, each $P_{j,k}$ lies on exactly one line 
$l_{i,k\sigma_{i,j}}$ containing $E_i$ for some permutation $\sigma_{i,j}$

Define a matrix $A$, where $A_{i,j}$ is the sign of $\sigma_{i,j}$ if 
$i\neq j$ and $A_{i,i}=0$ for all $i$.
The partial fingerprint is the multiset of entries of $|AA^t|$ where $A^t$ 
denotes the transposed matrix of $A$.

this is a ``small'' function.



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%
%E
%%

