Endomorphisms of the Fano Plane

The Fano plane is really a projective plane \mathbb{PZ}_{2}^{2}. This is just \mathbb{Z}_{2}^{3} missing the origin.

So lets study \mathbb{Z}_{2}^{3}. The first step is to study its symmetries.

We can recall that \mathrm{Aut}(\mathbb{Z}_{2}^{3}) is the general linear finite group \mathrm{GL}_{3}(2).

What will we do? Well, we will draw up the space \mathbb{Z}_{2}^{3} as a pair of tables, which would form a cube.

\displaystyle \begin{array}{c}\left[\begin{array}{cc}  3 & 1 \\ 7 & 5\end{array}\right]\\  \quad\\  \left[\begin{array}{cc}  2 & 0\\ 6 & 4\end{array}\right]\end{array}

We connect the North-West corner of the top square to the North-West corner of the bottom square; the North-East corner to the North-East corner, and so on. This constructs our cube. John Baez’s “Octonions” article gives us the following slightly different picture:

Writing the entries in binary gives us the vector form of the entry. So 7 in binary is 111 and then we clean it up (“pretty print”) to get (1,1,1) as the vector-form.

Exercise: rewrite each entry of the cube in vector-form.

Now, we have three basis vectors (represented by the numbers 1, 2, 4). We just have to study where these guys go.

If we write our matrix out as three row columns, and if our matrix is nondegenerate, then each column has a nonzero element of \mathbb{Z}_{8}. There are 7×6×5 = 210 possible transformations.

So we can write our matrix as a triple really (a, b, c) and if we use the vector notation for our vectors [x, y, z] — square brackets are used for vectors — then the resulting vector is, as a number, ax + by + cz \bmod8.

If the input is a number, then how do we implement this?

function Matrix(a,b,c)
{
    this.dat = [
        (typeof(a)!="number") ? 0 : a%8,
        (typeof(b)!="number") ? 0 : b%8,
        (typeof(c)!="number") ? 0 : c%8
        ];
}

Matrix.prototype.toString = function()
{
    return "("+this.dat[0]+", "+this.dat[1]+", "+this.dat[2]+")";
}

Matrix.prototype.mapVector = function(num)
{
    switch(num)
    {
        case 0: return 0;
        case 1: return this.dat[2];
        case 2: return this.dat[1];
        case 3: return (this.dat[1]^this.dat[2]);
        case 4: return this.dat[0];
        case 5: return (this.dat[0]^this.dat[2]);
        case 6: return (this.dat[0]^this.dat[1]);
        case 7: return (this.dat[0]^this.dat[1]^this.dat[2]);
        default: return 0;
    }
}

What about taking the transpose? Lets first note what are the symmetric 3×3 matrices, they are linear combinations of the following:
(2, 4, 0),
(1, 0, 4),
(0, 1, 2),
(4, 0, 0),
(0, 2, 0),
(0, 0, 1).

Matrix.prototype.transpose = function()
{
    Matrix ret = new Matrix();
    ret.dat[0] = 4*(this.dat[0]>4 ? 1 : 0) + 2*(this.dat[1]>4 ? 1 : 0) + (this.dat[2]>4 ? 1 : 0);
    ret.dat[1] = 4*(this.dat[0]%4>1 ? 1 : 0) + 2*(this.dat[1]%4>1 ? 1 : 0) + (this.dat[2]%4>1 ? 1 : 0);
    ret.dat[2] = 4*(this.dat[0]%2) + 2*(this.dat[1]%2) + (this.dat[2]%2);
    return ret;
}

So we have just produced a triple to represent our linear transformation. It is nondegenerate if no member of the triple is zero, and if there are no duplicates. So (3, 2, 3) is degenerate since 3 is repeated. But (1, 2, 7) is nondegenerate.

Observe if all members of the triple are less than 4, the triple is degenerate (proof: the first row is all zeroes, so the determinant must vanish). Likewise, if all members are even, the triple is degenerate (the third row is all zeroes).

When the entries are all 1, 4, 5, then the triple is degenerate (the middle row vanishes).

In all other cases, the matrix is non-degenerate and may be used.

WordPress won’t let me embed the program into a post (it’s “dangerous”!). So here’s the source code for you to copy/paste into a html file on your computer:

<html>
<head>
  <title>Fano Plane</title>
<script type="text/javascript">
function Matrix(a,b,c)
{
    this.dat = [
        (typeof(a)!="number") ? 0 : a%8,
        (typeof(b)!="number") ? 0 : b%8,
        (typeof(c)!="number") ? 0 : c%8
        ];
}

Matrix.prototype.toString = function()
{
    return "("+this.dat[0]+", "+this.dat[1]+", "+this.dat[2]+")";
}

Matrix.prototype.mapVector = function(num)
{
    switch(num)
    {
        case 0: return 0;
        case 1: return this.dat[2];
        case 2: return this.dat[1];
        case 3: return (this.dat[1]^this.dat[2]);
        case 4: return this.dat[0];
        case 5: return (this.dat[0]^this.dat[2]);
        case 6: return (this.dat[0]^this.dat[1]);
        case 7: return (this.dat[0]^this.dat[1]^this.dat[2]);
        default: return 0;
    }
}

function fanoFunctionOne()
{
    var a,b,c;
    var i,j;
    // get the triple
    a = Number(document.matrixInput.matrixTriple1.value);
    b = Number(document.matrixInput.matrixTriple2.value);
    c = Number(document.matrixInput.matrixTriple3.value);
    // store it as a matrix triple
    var matrix = new Matrix(a,b,c);
    // write it out to entries
    document.getElementById('topNW').innerHTML = matrix.mapVector(3);
    document.getElementById("topNE").innerHTML = matrix.mapVector(1);
    document.getElementById("topSW").innerHTML = matrix.mapVector(7);
    document.getElementById("topSE").innerHTML = matrix.mapVector(5);
    document.getElementById("botNW").innerHTML = matrix.mapVector(2);
    document.getElementById("botNE").innerHTML = matrix.mapVector(0);
    document.getElementById("botSW").innerHTML = matrix.mapVector(6);
    document.getElementById("botSE").innerHTML = matrix.mapVector(4);
}
</script>
</head>
<body>
<form name="matrixInput">
  <label for="matrixTriple">Matrix as a triple (<i>a</i>, <i>b</i>, <i>c</i>):</label>
  (<input name="matrixTriple1" type="text" size=1 />,
  <input name="matrixTriple2" type="text" size=1 />,
  <input name="matrixTriple3" type="text" size=1 />)
  <input type="button" onclick="fanoFunctionOne()" value="Convert" />
</form>
<table>
<tr>
<td>
  <table border="1">
    <tr>
      <td>3</td>
      <td>1</td>
    </tr>
    <tr>
      <td>7</td>
      <td>5</td>
    </tr>
  </table>
  <br />
  <table border="1">
    <tr>
      <td> 2 </td>
      <td> 0 </td>
    </tr>
    <tr>
      <td> 6 </td>
      <td> 4 </td>
    </tr>
  </table>
</td>
<td style="width: 24px;">
</td>
<td>
 maps to
</td>
<td style="width: 24px;">
</td>
<td>
  <table border="1">
    <tr>
      <td id="topNW">3</td>
      <td id="topNE">1</td>
    </tr>
    <tr>
      <td id="topSW">7</td>
      <td id="topSE">5</td>
    </tr>
  </table>
  <br />
  <table border="1">
    <tr>
      <td id="botNW">2</td>
      <td id="botNE">0</td>
    </tr>
    <tr>
      <td id="botSW">6</td>
      <td id="botSE">4</td>
    </tr>
  </table>
</td>
</tr>
</table>
</body>
</html>

Exercise: what triples are lower diagonal?

Exercise: how do lower diagonal triples behave on the Fano plane?

Advertisements

About Alex Nelson

I like math. I like programming. Most of all, I love puzzles.
This entry was posted in Fano Plane, Linear Algebra, Projective Space. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s