genus.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Working with (local) genera of Hermitian lattices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Welcome to Nemo version 0.16.4-dev\n",
      "\n",
      "Nemo comes with absolutely no warranty whatsoever\n",
      "\n",
      "\n",
      "Welcome to \n"
     ]
    },
    {
     "data": {
      "text/html": [
       "$\\require{action}$"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\u001b[31m    _    _           _\u001b[39m\n",
      "\u001b[31m   | |  | |         | |\u001b[39m\n",
      "\u001b[31m   | |__| | ___  ___| | _____\u001b[39m\n",
      "\u001b[31m   |  __  |/ _ \\/ __| |/ / _ \\\u001b[39m\n",
      "\u001b[31m   | |  | |  __/ (__|   <  __/\u001b[39m\n",
      "\u001b[31m   |_|  |_|\\___|\\___|_|\\_\\___|\u001b[39m\n",
      "\u001b[31m    \u001b[39m\n",
      "Version\u001b[32m 0.7.3-dev \u001b[39m... \n",
      " ... which comes with absolutely no warranty whatsoever\n",
      "(c) 2015-2019 by Claus Fieker, Tommy Hofmann and Carlo Sircana\n",
      "\n"
     ]
    }
   ],
   "source": [
    "using Hecke;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the field extension $E/K$, where $K = \\mathbb Q(\\sqrt 2)$ and $E = K[t]/(t^2 - \\sqrt{2}  t + 2)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$\\text{Relative number field over }K\\text{ defined by }t^{2}+(-a)t+(1)$"
      ],
      "text/plain": [
       "Relative number field over\n",
       "Number field over Rational Field with defining polynomial x^2-2\n",
       " with defining polynomial t^2+(-a)*t+(1)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R, x = PolynomialRing(QQ, \"x\");\n",
    "K, a = NumberField(x^2 - 2, \"a\");\n",
    "Kt, t = K[\"t\"];\n",
    "E, b = number_field(t^2 - a * t + 1, \"b\");\n",
    "E"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now create the Hermitian space over $E/K$ with Gram matrix $$\\begin{pmatrix} 10 & 0 & 0 \\\\ 0 & 10 & 0 \\\\ 0 & 0 & 10 \\end{pmatrix}.$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hermitian space over\n",
       "Relative number field over\n",
       "Number field over Rational Field with defining polynomial x^2-2\n",
       " with defining polynomial t^2+(-a)*t+(1)\n",
       "with Gram matrix\n",
       "[(10)     0     0]\n",
       "[   0  (10)     0]\n",
       "[   0     0  (10)]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V = hermitian_space(E, 10*identity_matrix(ZZ, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "OK = maximal_order(K); OE = maximal_order(E);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = prime_decomposition(OK, 2)[1][1]; P = prime_decomposition(OE, p)[1][1];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "true"
      ],
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isramified(OE, p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now create a lattice in $V$ with a certain basis pseudo-matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hermitian lattice of rank 3 and degree 3\n",
       "over\n",
       "Relative maximal order with pseudo-basis ((1)) * 1//1 * <1, 1>, (b) * 1//1 * <1, 1>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " L = lattice(V, pseudo_matrix(identity_matrix(E, 3), [P, P, 1 * OE]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now compute the local genus of $L$ at $\\mathfrak p$ and then the genus of $L$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Local genus symbol (rank, scale, det, norm) at <2, a>:\n",
       "(4, 1, +, 2)(6, 2, +, 3)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Gp = genus(L, p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Global genus symbol\n",
       "<2, a> => (4, 1, +, 2) (6, 2, +, 3)\n",
       "<5, 5> => (1, 3, +)\n",
       "1.4142135… => 0\n",
       "-1.414213… => 0"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G = genus(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check if a lattice is contained in a genus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "true"
      ],
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L in Gp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "true"
      ],
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L in G"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can ask for properties of a local genus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "($2$, $3$, $[4, 6]$, $[1, 2]$, $[1, 1]$)"
      ],
      "text/plain": [
       "(2, 3, [4, 6], [1, 2], [1, 1])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "length(Gp), rank(Gp), Hecke.scales(Gp), Hecke.ranks(Gp), Hecke.dets(Gp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also access the invariants for individual Jordan blocks in the Jordan decomposition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "($1$, $4$, $1$)"
      ],
      "text/plain": [
       "(1, 4, 1)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rank(Gp, 1), scale(Gp, 1), det(Gp, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can list local genera. Let us list all local genera at $\\mathfrak p$ of lattices of rank $4$, determinant valuation at most $2$ and scale at most $4$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$[(0, 3, +, 0) (4, 1, +, 2), (0, 3, -, 0) (4, 1, +, 2), (0, 3, +, 0) (4, 1, -, 2), (0, 3, -, 0) (4, 1, -, 2), (0, 2, +, 0) (2, 2, +, 1), (0, 2, -, 0) (2, 2, +, 1), (0, 2, +, 1) (2, 2, +, 1), (0, 2, +, 1) (2, 2, -, 1), (0, 2, +, 0) (2, 2, +, 2), (0, 2, -, 0) (2, 2, +, 2), (0, 2, +, 1) (2, 2, +, 2), (0, 1, +, 0) (1, 2, +, 1) (2, 1, +, 1), (0, 1, -, 0) (1, 2, +, 1) (2, 1, +, 1), (1, 4, +, 1), (1, 4, -, 1)]$"
      ],
      "text/plain": [
       "15-element Array{Hecke.LocalGenusHerm{Hecke.NfRel{nf_elem},NfAbsOrdIdl{AnticNumberField,nf_elem}},1}:\n",
       " (0, 3, +, 0) (4, 1, +, 2)\n",
       " (0, 3, -, 0) (4, 1, +, 2)\n",
       " (0, 3, +, 0) (4, 1, -, 2)\n",
       " (0, 3, -, 0) (4, 1, -, 2)\n",
       " (0, 2, +, 0) (2, 2, +, 1)\n",
       " (0, 2, -, 0) (2, 2, +, 1)\n",
       " (0, 2, +, 1) (2, 2, +, 1)\n",
       " (0, 2, +, 1) (2, 2, -, 1)\n",
       " (0, 2, +, 0) (2, 2, +, 2)\n",
       " (0, 2, -, 0) (2, 2, +, 2)\n",
       " (0, 2, +, 1) (2, 2, +, 2)\n",
       " (0, 1, +, 0) (1, 2, +, 1) (2, 1, +, 1)\n",
       " (0, 1, -, 0) (1, 2, +, 1) (2, 1, +, 1)\n",
       " (1, 4, +, 1)\n",
       " (1, 4, -, 1)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = local_genera_hermitian(E, p, 4, 2, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can construct for every local genus a representative (and check if it is contained in the genus):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 3, +, 0) (4, 1, +, 2)\n",
      "(0, 3, -, 0) (4, 1, +, 2)\n",
      "(0, 3, +, 0) (4, 1, -, 2)\n",
      "(0, 3, -, 0) (4, 1, -, 2)\n",
      "(0, 2, +, 0) (2, 2, +, 1)\n",
      "(0, 2, -, 0) (2, 2, +, 1)\n",
      "(0, 2, +, 1) (2, 2, +, 1)\n",
      "(0, 2, +, 1) (2, 2, -, 1)\n",
      "(0, 2, +, 0) (2, 2, +, 2)\n",
      "(0, 2, -, 0) (2, 2, +, 2)\n",
      "(0, 2, +, 1) (2, 2, +, 2)\n",
      "(0, 1, +, 0) (1, 2, +, 1) (2, 1, +, 1)\n",
      "(0, 1, -, 0) (1, 2, +, 1) (2, 1, +, 1)\n",
      "(1, 4, +, 1)\n",
      "(1, 4, -, 1)\n"
     ]
    }
   ],
   "source": [
    "for G in X\n",
    "    M = representative(G)\n",
    "    println(G)\n",
    "    @assert M in G\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "kernelspec": {
   "display_name": "Julia 1.4.0-rc1",
   "language": "julia",
   "name": "julia-1.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.4.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}