This is PencilsOfQuadrics.info, produced by Macaulay2, version 1.25.05

PencilsOfQuadrics -- Clifford Algebra of a Pencil of quadratic forms on PP^(2g+1)
*********************************************************************************

Description
===========

The Clifford algebra forms a link between the intersection of two quadrics X
and a hyperelliptic curve E. For example, one can recover the coordinate ring
of the hyperelliptic curve as the center of the even Clifford algebra. Using a
maximal linear subspace contained in the intersection, we get a Morita bundle
that connects graded modules over the coordinate ring of the hyperelliptic
curve and modules over the even Clifford algebra.  This leads to a proof of
Reid's theorem which identifies the set of maximal isotropic subspaces in the
complete intersection of two quadrics to the set of degree 0 line bundles on E.
This approach was taken in an unpublished manuscript of Ragnar-Olaf Buchweitz
and Frank-Olaf Schreyer. The package allows a computational approach to the
result of Bondal and Orlov which showed that the Kuznetsov component of X and
the derived category of E are equivalent by a Fourier-Mukai transformation (see
Section 2 of [A. Bondal, D. Orlov, arXiv:alg-geom/9506012], or Section 6 of [A.
Bondal, D. Orlov, Proceedings of ICM, Vol. II (Beijing, 2002)]).

We demonstrate this, over finite fields, with the constructions of further
random linear spaces on the intersection of two quadrics, and random Ulrich
modules of lowest possible rank on the complete intersection of two quadrics
for small g.

Types
=====

  * CliffordModule -- hash table holding details of a
    Clifford module
  * RandomNicePencil -- hash table holding details of
    a random pencil of quadrics
  * VectorBundleOnE -- vector bundle on a hyperelliptic
    curve E

Basic Construction of the Clifford Algebra
==========================================

  * cliffordOperators -- Generators for a Clifford
    Algebra
  * symMatrix -- part of a CliffordModule
  * centers -- even and odd action of the center of the even
    Clifford algebra
  * evenCenter -- part of a CliffordModule
  * oddCenter -- part of a CliffordModule
  * hyperellipticBranchEquation -- part of
    a CliffordModule

Vector Bundles
==============

  * preRandomLineBundle -- a random line bundle on
    the hyperelliptic curve
  * randomLineBundle -- a random balanced line bundle
    on the hyperelliptic curve
  * vectorBundleOnE -- creates a VectorBundleOnE,
    represented as a matrix factorization
  * yAction -- defines a vector bundle on E
  * tensorProduct -- tensor product of sheaves on the
    elliptic curve or sheaf times CliffordModule
  * degOnE -- degree of a vector bundle on E
  * orderInPic -- order of a line bundle of degree 0 in
    Pic(E)
  * randomExtension -- a random extension of a vector
    bundle on E by another vector bundle

Clifford Modules
================

  * cliffordModule -- makes a clifford Module
  * tensorProduct -- tensor product of sheaves on the
    elliptic curve or sheaf times CliffordModule
  * evenOperators -- part of a CliffordModule
  * oddOperators -- part of a CliffordModule

Computations using Clifford Algebras
====================================

  * translateIsotropicSubspace -- choose a
    random isotropic subspace
  * randomIsotropicSubspace -- choose a random
    isotropic subspace
  * searchUlrich -- searching an Ulrich module of smallest
    possible rank, or an Ulrich module of given rank.
  * LabBookProtocol -- Print commands that lead to a
    construction of a Ulrich bundle

Authors
=======

  * Frank-Olaf Schreyer (see https://www.math.uni-sb.de/ag/schreyer/index.php/
    ) <schreyer@math.uni-sb.de>
  * David Eisenbud (see https://eisenbud.github.io/ ) <de@msri.org>
  * Yeongrak Kim (see https://sites.google.com/view/yeongrak )
    <yeongrak.kim@pusan.ac.kr>

Version
=======

This documentation describes version 1.0 of PencilsOfQuadrics.

Citation
========

If you have used this package in your research, please cite it as follows:

+-----------------------------------------------------------------------------+
|@misc{PencilsOfQuadricsSource,                                               |
|  title = {{PencilsOfQuadrics: Clifford Algebra of a pencil of quadratic form|
|  author = {Frank-Olaf Schreyer and David Eisenbud and Yeongrak Kim},        |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/master/M2/Macaulay2/packages}} |
|}                                                                            |
|-----------------------------------------------------------------------------|
|s. Version~1.0}},                                                            |
+-----------------------------------------------------------------------------+

Exports
=======

  * Types
      * CliffordModule -- hash table holding details of
        a Clifford module
      * RandomNicePencil -- hash table holding details
        of a random pencil of quadrics
      * VectorBundleOnE -- vector bundle on a
        hyperelliptic curve E
  * Functions and commands
      * centers -- even and odd action of the center of the
        even Clifford algebra
      * ciModuleToCliffordModule -- transforms
        a module over a complete intersection of 2 quadrics into a Clifford
        Module.
      * ciModuleToMatrixFactorization, --
        transforms a module over a complete intersection of 2 quadrics into a
        matrix factorization
      * cliffordModule -- makes a clifford Module
      * cliffordModuleToCIResolution, --
        transforms a Clifford module to a resolution over a complete
        intersection ring
      * cliffordModuleToMatrixFactorization
        -- reads off a matrix
        factorization from a Clifford module
      * cliffordOperators -- Generators for a
        Clifford Algebra
      * degOnE -- degree of a vector bundle on E
      * LabBookProtocol -- Print commands that lead to
        a construction of a Ulrich bundle
      * matrixFactorizationK -- Knoerrer matrix
        factorization from a bilinear form X*transpose Y
      * orderInPic -- order of a line bundle of degree 0 in
        Pic(E)
      * preRandomLineBundle -- a random line bundle
        on the hyperelliptic curve
      * randNicePencil -- sets up a random pencil of
        quadrics, and returns a hash table of the type RandomNicePencil.
      * randomExtension -- a random extension of a
        vector bundle on E by another vector bundle
      * randomIsotropicSubspace -- choose a
        random isotropic subspace
      * randomLineBundle -- a random balanced line
        bundle on the hyperelliptic curve
      * randomNicePencil -- sets up a random example
        to construct Clifford algebra and representation
      * searchUlrich -- searching an Ulrich module of
        smallest possible rank, or an Ulrich module of given rank.
      * symMatrix -- part of a CliffordModule
      * tensorProduct -- tensor product of sheaves on the
        elliptic curve or sheaf times CliffordModule
      * translateIsotropicSubspace -- choose
        a random isotropic subspace
      * vectorBundleOnE -- creates a VectorBundleOnE,
        represented as a matrix factorization
  * Methods
      * "centers(List,List)" -- see centers, -- even and odd
        action of the center of the even Clifford algebra
      * "ciModuleToCliffordModule(Module)" -- see
        ciModuleToCliffordModule, -- transforms a
        module over a complete intersection of 2 quadrics into a Clifford
        Module.
      * "ciModuleToMatrixFactorization(Module)" -- see
        ciModuleToMatrixFactorization, --
        transforms a module over a complete intersection of 2 quadrics into a
        matrix factorization
      * "cliffordModule(List,List)" -- see cliffordModule,
        -- makes a clifford Module
      * "cliffordModule(Matrix,Matrix,Ring)" -- see cliffordModule,
        -- makes a clifford Module
      * "cliffordModuleToCIResolution(CliffordModule,Ring,Ring)" -- see
        cliffordModuleToCIResolution, --
        transforms a Clifford module to a resolution over a complete
        intersection ring
      * "cliffordModuleToMatrixFactorization(CliffordModule,Ring)" -- see
        cliffordModuleToMatrixFactorization,
        -- reads off a matrix
        factorization from a Clifford module
      * "cliffordOperators(Matrix,Matrix,Ring)" -- see cliffordOperators,
        -- Generators for a Clifford Algebra
      * "degOnE(Matrix)" -- see degOnE, -- degree of a vector
        bundle on E
      * "degOnE(VectorBundleOnE)" -- see degOnE, -- degree of a
        vector bundle on E
      * "LabBookProtocol(ZZ)" -- see LabBookProtocol, --
        Print commands that lead to a construction of a Ulrich bundle
      * "LabBookProtocol(ZZ,ZZ)" -- see LabBookProtocol,
        -- Print commands that lead to a construction of a Ulrich bundle
      * "matrixFactorizationK(Matrix,Matrix)" -- see
        matrixFactorizationK, -- Knoerrer matrix
        factorization from a bilinear form X*transpose Y
      * "orderInPic(Matrix)" -- see orderInPic, -- order of a
        line bundle of degree 0 in Pic(E)
      * "orderInPic(VectorBundleOnE)" -- see orderInPic, --
        order of a line bundle of degree 0 in Pic(E)
      * "preRandomLineBundle(RingElement)" -- see preRandomLineBundle,
        -- a random line bundle on the hyperelliptic curve
      * "preRandomLineBundle(ZZ,RingElement)" -- see preRandomLineBundle,
        -- a random line bundle on the hyperelliptic curve
      * "randNicePencil(Ring,ZZ)" -- see randNicePencil,
        -- sets up a random pencil of quadrics, and returns a hash table of the
        type RandomNicePencil.
      * "randomExtension(Matrix,Matrix)" -- see randomExtension,
        -- a random extension of a vector bundle on E by
        another vector bundle
      * "randomExtension(VectorBundleOnE,VectorBundleOnE)" -- see
        randomExtension, -- a random extension of a vector
        bundle on E by another vector bundle
      * "randomIsotropicSubspace(CliffordModule,PolynomialRing)" -- see
        randomIsotropicSubspace, -- choose a random
        isotropic subspace
      * "randomLineBundle(RingElement)" -- see randomLineBundle,
        -- a random balanced line bundle on the hyperelliptic
        curve
      * "randomLineBundle(ZZ,RingElement)" -- see randomLineBundle,
        -- a random balanced line bundle on the hyperelliptic
        curve
      * "randomNicePencil(Ring,ZZ)" -- see randomNicePencil,
        -- sets up a random example to construct Clifford
        algebra and representation
      * "searchUlrich(CliffordModule,Ring)" -- see searchUlrich,
        -- searching an Ulrich module of smallest possible rank,
        or an Ulrich module of given rank.
      * "searchUlrich(CliffordModule,Ring,ZZ)" -- see searchUlrich,
        -- searching an Ulrich module of smallest possible rank,
        or an Ulrich module of given rank.
      * "tensorProduct(CliffordModule,VectorBundleOnE)" -- see
        tensorProduct, -- tensor product of sheaves on the
        elliptic curve or sheaf times CliffordModule
      * "tensorProduct(Matrix,Matrix)" -- see tensorProduct,
        -- tensor product of sheaves on the elliptic curve or
        sheaf times CliffordModule
      * "tensorProduct(VectorBundleOnE,VectorBundleOnE)" -- see
        tensorProduct, -- tensor product of sheaves on the
        elliptic curve or sheaf times CliffordModule
      * "translateIsotropicSubspace(CliffordModule,VectorBundleOnE,
        PolynomialRing)" -- see translateIsotropicSubspace,
        -- choose a random isotropic subspace
      * "vectorBundleOnE(Matrix)" -- see vectorBundleOnE,
        -- creates a VectorBundleOnE, represented as a matrix
        factorization
  * Symbols
      * evenCenter -- part of a CliffordModule
      * evenOperators -- part of a CliffordModule
      * hyperellipticBranchEquation -- part
        of a CliffordModule
      * isotropicSpace -- part of a RandomNicePencil
      * matFact1 -- part of a RandomNicePencil
      * matFact2 -- part of a RandomNicePencil
      * matFactu1 -- part of a RandomNicePencil
      * matFactu2 -- part of a RandomNicePencil
      * oddCenter -- part of a CliffordModule
      * oddOperators -- part of a CliffordModule
      * qqRing -- part of a RandomNicePencil
      * quadraticForm -- part of a RandomNicePencil
      * symmetricM -- part of a CliffordModule
      * yAction -- defines a vector bundle on E

For the programmer
==================

The object PencilsOfQuadrics, is a package (Macaulay2Doc),
defined in PencilsOfQuadrics.m2.

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:1751:0.

baseRing of a RandomNicePencil -- part of a RandomNicePencil
************************************************************

  * Usage:
        R = rNP.baseRing
  * Outputs:
      * R, a ring (Macaulay2Doc), polynomial ring kk[s,t]

The base ring kk[s,t] which is the coordnate ring of PP^1. g=1; kk=ZZ/101;
rNP=randNicePencil(kk,g);

R=rNP.baseRing

See also
========

  * qqRing -- part of a RandomNicePencil
  * quadraticForm -- part of a RandomNicePencil
  * matFact1 -- part of a RandomNicePencil
  * matFact2 -- part of a RandomNicePencil
  * matFactu1 -- part of a RandomNicePencil
  * matFactu2 -- part of a RandomNicePencil
  * isotropicSpace -- part of a RandomNicePencil
-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2383:0.

centers -- even and odd action of the center of the even Clifford algebra
*************************************************************************

  * Usage:
        (c1,c2) = centers(eOdd,eEv)
  * Inputs:
      * eOdd, a list (Macaulay2Doc),
      * eEv, a list (Macaulay2Doc), lists output by
        cliffordOperators(M1, M2)
  * Outputs:
      * c1, a matrix (Macaulay2Doc),
      * c2, a matrix (Macaulay2Doc), action of the center on the
        even and odd modules

Description
===========

The center of the even Clifford algebra of an even-dimensional nonsingular
quadratic form represented by its symmetric matrix of coefficients sM is a
degree 2 extension of the ground ring with R[y]/(y^2- (-1)^d*f), where f is the
branch equation, f = det sM. The action of y on the  odd and even parts of a
Clifford Module is represented by the pair of matrices  c0, c1 which can be
computed by the following formula of Haag (see Satz 1 of [U. Haag, Arch. Math.
57, 546-554 (1991)]).

Let M be the clifford module, with operators eOdd and eEv as usual, and let sM
be the 2d x 2d symmetric matrix of the quadratic form, produced by
M.symmetricM. Let skM be the alternating matrix formed by taking the "top half"
of sM and subtracting the "bottom half". For any even length ordered sublist I
= i_1,i_2...i_{2k} of [2d], let eo_I = eEv_{i_1}*eOdd_{i_1} \cdots
eEv_{i_{2k}}*eOdd_{i_{2k}} and, similarly, oe_I = eOdd_{i_1}*eEv_{i_1} \cdots
eOdd_{i_{2k}}*eEv_{i_{2k}}. Let J be the complement of I. Then

c1 = sum (-1)^{sgn J} Pfaffian((skM_J)^J)*eo_I

c0 = sum (-1)^{sgn J} Pfaffian((skM_J)^J)*oe_I

where the index I runs over all even length ordered subsets of [2d].

+-----------------------------------------------------------------+
|i1 : setRandomSeed 0                                             |
| -- setting random seed to 0                                     |
|                                                                 |
|o1 = 0                                                           |
+-----------------------------------------------------------------+
|i2 : kk=ZZ/101; d=1;                                             |
+-----------------------------------------------------------------+
|i4 : n=2*d                                                       |
|                                                                 |
|o4 = 2                                                           |
+-----------------------------------------------------------------+
|i5 : R=kk[a_0..a_(binomial(n+2,2)-1)]                            |
|                                                                 |
|o5 = R                                                           |
|                                                                 |
|o5 : PolynomialRing                                              |
+-----------------------------------------------------------------+
|i6 : S=kk[x_0..x_(n-1),a_0..a_(binomial(n+2,2)-1)]               |
|                                                                 |
|o6 = S                                                           |
|                                                                 |
|o6 : PolynomialRing                                              |
+-----------------------------------------------------------------+
|i7 : M=genericSymmetricMatrix(S,a_0,n)                           |
|                                                                 |
|o7 = | a_0 a_1 |                                                 |
|     | a_1 a_2 |                                                 |
|                                                                 |
|             2      2                                            |
|o7 : Matrix S  <-- S                                             |
+-----------------------------------------------------------------+
|i8 : X=(vars S)_{0..n-1}                                         |
|                                                                 |
|o8 = | x_0 x_1 |                                                 |
|                                                                 |
|             1      2                                            |
|o8 : Matrix S  <-- S                                             |
+-----------------------------------------------------------------+
|i9 : Y=X*M                                                       |
|                                                                 |
|o9 = | x_0a_0+x_1a_1 x_0a_1+x_1a_2 |                             |
|                                                                 |
|             1      2                                            |
|o9 : Matrix S  <-- S                                             |
+-----------------------------------------------------------------+
|i10 : (M1,M2)=matrixFactorizationK(X,Y);                         |
+-----------------------------------------------------------------+
|i11 : (eOdd,eEv)=cliffordOperators(M1,M2,R);                     |
+-----------------------------------------------------------------+
|i12 : sM = symMatrix(eOdd,eEv)                                   |
|                                                                 |
|o12 = | a_0 a_1 |                                                |
|      | a_1 a_2 |                                                |
|                                                                 |
|              2      2                                           |
|o12 : Matrix R  <-- R                                            |
+-----------------------------------------------------------------+
|i13 : f = det sM                                                 |
|                                                                 |
|         2                                                       |
|o13 = - a  + a a                                                 |
|         1    0 2                                                |
|                                                                 |
|o13 : R                                                          |
+-----------------------------------------------------------------+
|i14 : f == (cliffordModule(eOdd,eEv)).hyperellipticBranchEquation|
|                                                                 |
|o14 = true                                                       |
+-----------------------------------------------------------------+
|i15 : (c0,c1)=centers(eOdd,eEv)                                  |
|                                                                 |
|o15 = ({-3} | 0  -a_1^2+a_0a_2 |, {-1} | -a_1 -a_2 |)            |
|       {-2} | -1 0             |  {-1} | a_0  a_1  |             |
|                                                                 |
|o15 : Sequence                                                   |
+-----------------------------------------------------------------+
|i16 : assert(c0^2-(-1)^d*f*id_(source c0)==0)                    |
+-----------------------------------------------------------------+
|i17 : assert(c1^2-(-1)^d*f*id_(source c1)==0)                    |
+-----------------------------------------------------------------+

See also
========

  * matrixFactorizationK -- Knoerrer matrix
    factorization from a bilinear form X*transpose Y
  * symMatrix -- part of a CliffordModule
  * hyperellipticBranchEquation -- part of
    a CliffordModule

Ways to use centers:
====================

  * "centers(List,List)"

For the programmer
==================

The object centers, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2789:0.

ciModuleToCliffordModule -- transforms a module over a complete intersection of 2 quadrics into a Clifford Module.
******************************************************************************************************************

  * Usage:
        C = ciModuleToCliffordModule M
  * Inputs:
      * M, a module (Macaulay2Doc), module over a complete
        intersection of 2 quadrics
  * Outputs:
      * C, an instance of the type CliffordModule,

Description
===========

Part of the series of explicit functors giving category equivalences:

cliffordModule

cliffordModuleToCIResolution

cliffordModuleToMatrixFactorization

ciModuleToMatrixFactorization

ciModuleToCliffordModule

This function uses ciModuleToMatrixFactorization, and then calls cliffordModule

+-----------------------------------------------------------------------------+
|i1 : n = 4                                                                   |
|                                                                             |
|o1 = 4                                                                       |
+-----------------------------------------------------------------------------+
|i2 : c = 2                                                                   |
|                                                                             |
|o2 = 2                                                                       |
+-----------------------------------------------------------------------------+
|i3 : kk = ZZ/101                                                             |
|                                                                             |
|o3 = kk                                                                      |
|                                                                             |
|o3 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i4 : U = kk[x_0..x_(n-1)]                                                    |
|                                                                             |
|o4 = U                                                                       |
|                                                                             |
|o4 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i5 : qq = matrix{{x_0^2+x_1^2,x_0*x_1}}                                      |
|                                                                             |
|o5 = | x_0^2+x_1^2 x_0x_1 |                                                  |
|                                                                             |
|             1      2                                                        |
|o5 : Matrix U  <-- U                                                         |
+-----------------------------------------------------------------------------+
|i6 : qq = random(U^1, U^{2:-2})                                              |
|                                                                             |
|o6 = | 24x_0^2-36x_0x_1+19x_1^2-30x_0x_2+19x_1x_2-29x_2^2-29x_0x_3-10x_1x_3- |
|     ------------------------------------------------------------------------|
|     8x_2x_3-22x_3^2 -29x_0^2-24x_0x_1+39x_1^2-38x_0x_2+21x_1x_2+19x_2^2-16x_|
|     ------------------------------------------------------------------------|
|     0x_3+34x_1x_3-47x_2x_3-39x_3^2 |                                        |
|                                                                             |
|             1      2                                                        |
|o6 : Matrix U  <-- U                                                         |
+-----------------------------------------------------------------------------+
|i7 : Ubar = U/ideal qq                                                       |
|                                                                             |
|o7 = Ubar                                                                    |
|                                                                             |
|o7 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i8 : M = coker vars Ubar                                                     |
|                                                                             |
|o8 = cokernel | x_0 x_1 x_2 x_3 |                                            |
|                                                                             |
|                                  1                                          |
|o8 : Ubar-module, quotient of Ubar                                           |
+-----------------------------------------------------------------------------+
|i9 : M = coker random(Ubar^2, Ubar^{-1,-2,-2})                               |
|                                                                             |
|o9 = cokernel | -18x_0-43x_1-28x_2+38x_3 -16x_1^2+16x_0x_2+39x_1x_2-38x_2^2  |
|              | -13x_0-15x_1-47x_2+2x_3  15x_1^2+45x_0x_2-17x_1x_2+40x_2^2+  |
|                                                                             |
|                                  2                                          |
|o9 : Ubar-module, quotient of Ubar                                           |
|-----------------------------------------------------------------------------|
|-48x_0x_3+48x_1x_3+46x_2x_3+22x_3^2                                          |
|47x_0x_3+35x_1x_3+x_2x_3-23x_3^2                                             |
|-----------------------------------------------------------------------------|
|7x_1^2+22x_0x_2+43x_1x_2+33x_2^2-47x_0x_3+36x_1x_3-28x_2x_3-47x_3^2 |        |
|-23x_1^2-34x_0x_2-11x_1x_2+11x_2^2+19x_0x_3+11x_1x_3-3x_2x_3-7x_3^2 |        |
+-----------------------------------------------------------------------------+
|i10 : C = ciModuleToCliffordModule M                                         |
|                                                                             |
|o10 = CliffordModule{...6...}                                                |
|                                                                             |
|o10 : CliffordModule                                                         |
+-----------------------------------------------------------------------------+
|i11 : keys C                                                                 |
|                                                                             |
|o11 = {hyperellipticBranchEquation, oddCenter, evenOperators, symmetricM,    |
|      -----------------------------------------------------------------------|
|      evenCenter, oddOperators}                                              |
|                                                                             |
|o11 : List                                                                   |
+-----------------------------------------------------------------------------+
|i12 : C.evenOperators                                                        |
|                                                                             |
|o12 = {{-1} | 0 0 0   -48t -38t2    -30t2    24st-23t2 -22t2    -3t2         |
|       {0}  | 0 0 -6  15   -29s+49t 3t       46s-40t   -46t     -40t         |
|       {0}  | 0 0 41  21   -47s-4t  -20s+38t 47s-16t   13s+28t  18s-44t      |
|       {0}  | 0 0 -29 4    7t       -11s-36t -47s+35t  -46s-27t 6s+39t       |
|       {0}  | 0 0 7   -34  30s+41t  28s-23t  44s-21t   -11s-47t -47s+42t     |
|       {0}  | 0 0 12  20   24s+50t  28s+30t  -10s+24t  28s-24t  -37s+40t     |
|       {0}  | 0 0 0   -44  -40s+16t -49s-41t 32s+25t   -43s-3t  -7s+45t      |
|       {0}  | 0 0 0   0    0        0        0         0        0            |
|       {1}  | 0 0 0   0    0        0        0         0        0            |
|       {1}  | 0 0 0   0    0        0        0         0        0            |
|       {2}  | 0 0 0   0    0        0        0         0        0            |
|       {2}  | 0 0 0   0    0        0        0         0        0            |
|      -----------------------------------------------------------------------|
|      -31t2    27st2+40t3      0            |, {-1} | 0 0 43t 42t 39st-6t2   |
|      -11t     -29st-40t2      0            |  {0}  | 0 0 -43 -44 36s-9t     |
|      -6s+12t  29s2+22st+12t2  0            |  {0}  | 0 0 -21 37  5s-4t      |
|      -44s+26t -30s2+44st+13t2 0            |  {0}  | 0 0 33  -46 28s-32t    |
|      24s-45t  -27s2-44st-41t2 0            |  {0}  | 0 0 4   -5  46s+31t    |
|      26s+18t  35st-49t2       0            |  {0}  | 0 0 -16 28  40s-t      |
|      28s+9t   49st-26t2       0            |  {0}  | 0 0 0   47  -44s       |
|      0        0               -39s2t-48st2 |  {0}  | 0 0 0   0   0          |
|      0        0               28st+15t2    |  {1}  | 0 0 0   0   0          |
|      0        0               40st-33t2    |  {1}  | 0 0 0   0   0          |
|      0        0               13s-10t      |  {2}  | 0 0 0   0   0          |
|      0        0               -31s+37t     |  {2}  | 0 0 0   0   0          |
|      -----------------------------------------------------------------------|
|      22st+27t2 -9st+13t2 45st+24t2 -22st+29t2 43st-44t2 -7st2+3t3           |
|      -32s-41t  -7s+26t   -23s+14t  28s-38t    -11s+9t   -28st+16t2          |
|      19s-34t   41s-34t   -4s+10t   -50s-37t   26s-5t    -27s2-50st+25t2     |
|      s-32t     -16s+27t  37s+24t   -7s-23t    50s-16t   -40s2+16t2          |
|      -50s-47t  -46s-15t  25s-43t   34s+25t    15s-34t   -s2-4st+10t2        |
|      -s+50t    27s       26s       -23s+27t   3s        39st                |
|      -23s-35t  35s       13s       -45s+14t   -45s      43st                |
|      0         0         0         0          0         0                   |
|      0         0         0         0          0         0                   |
|      0         0         0         0          0         0                   |
|      0         0         0         0          0         0                   |
|      0         0         0         0          0         0                   |
|      -----------------------------------------------------------------------|
|      0              |, {-1} | 0   24s+14t 0  0  0       0      0            |
|      0              |  {0}  | 24  -41     0  0  0       0      0            |
|      0              |  {0}  | -36 10      0  0  0       0      0            |
|      0              |  {0}  | 19  -23     0  0  0       0      0            |
|      0              |  {0}  | 0   -36     0  0  0       0      0            |
|      0              |  {0}  | -30 6       0  0  0       0      0            |
|      0              |  {0}  | 0   32      0  0  0       0      0            |
|      9s2t-10st2+2t3 |  {0}  | 0   0       35 37 49s+46t -9s-4t -3s-43t      |
|      3st-38t2       |  {1}  | 0   0       0  0  16      22     27           |
|      -47st+2t2      |  {1}  | 0   0       0  0  32      -47    -21          |
|      30s+40t        |  {2}  | 0   0       0  0  0       0      0            |
|      14s+24t        |  {2}  | 0   0       0  0  0       0      0            |
|      -----------------------------------------------------------------------|
|      0        0        0       0         0 |, {-1} | 0   -29s+25t 0  0      |
|      0        0        0       0         0 |  {0}  | -29 -22      0  0      |
|      0        0        0       0         0 |  {0}  | -24 38       0  0      |
|      0        0        0       0         0 |  {0}  | 39  -5       0  0      |
|      0        0        0       0         0 |  {0}  | 0   49       0  0      |
|      0        0        0       0         0 |  {0}  | -38 47       0  0      |
|      0        0        0       0         0 |  {0}  | 0   -24      0  0      |
|      -48s-35t -11s-39t 49s-20t 32st-14t2 0 |  {0}  | 0   0        -1 -28    |
|      3        -28      30      10t       0 |  {1}  | 0   0        0  0      |
|      2        -26      -9      30t       0 |  {1}  | 0   0        0  0      |
|      0        0        0       -20       0 |  {2}  | 0   0        0  0      |
|      0        0        0       27        0 |  {2}  | 0   0        0  0      |
|      -----------------------------------------------------------------------|
|      0       0       0       0       0      0       0         0 |}          |
|      0       0       0       0       0      0       0         0 |           |
|      0       0       0       0       0      0       0         0 |           |
|      0       0       0       0       0      0       0         0 |           |
|      0       0       0       0       0      0       0         0 |           |
|      0       0       0       0       0      0       0         0 |           |
|      0       0       0       0       0      0       0         0 |           |
|      -2s+31t 31s+47t -8s+15t 28s+43t 8s-47t -49s-3t 37st-35t2 0 |           |
|      -29     -38     17      -39     30     -8      37t       0 |           |
|      -31     -50     -29     -34     21     -48     -42t      0 |           |
|      0       0       0       0       0      0       -48       0 |           |
|      0       0       0       0       0      0       -20       0 |           |
|                                                                             |
|o12 : List                                                                   |
+-----------------------------------------------------------------------------+
|i13 : C.symmetricM                                                           |
|                                                                             |
|o13 = | 0        0       -15s-41t -19s-40t |                                 |
|      | 0        0       36s-5t   -8s+17t  |                                 |
|      | -15s-41t 36s-5t  0        0        |                                 |
|      | -19s-40t -8s+17t 0        0        |                                 |
|                                                                             |
|                       4               4                                     |
|o13 : Matrix (kk[s, t])  <-- (kk[s, t])                                      |
+-----------------------------------------------------------------------------+
|i14 : C.evenCenter                                                           |
|                                                                             |
|o14 = {1} | 4s2-4st-12t2 0            0              0                       |
|      {1} | 0            4s2-4st-12t2 0              0                       |
|      {1} | 0            0            -39s2+20st+3t2 -35s2-8st+8t2           |
|      {1} | 0            0            33s2-st-29t2   -25s2-31st-22t2         |
|      {2} | 0            0            10s-17t        48s-28t                 |
|      {2} | 0            0            32s+22t        -40s-36t                |
|      {2} | 0            0            -35s-40t       -s+43t                  |
|      {2} | 0            0            2s+48t         29s+22t                 |
|      {2} | 0            0            19s+22t        16s-4t                  |
|      {2} | 0            0            -37s+11t       -17s+27t                |
|      {3} | 0            0            0              0                       |
|      {0} | 0            0            0              0                       |
|      -----------------------------------------------------------------------|
|      0                      0                     0                         |
|      0                      0                     0                         |
|      -25s3-42s2t-14st2-27t3 43s3+23s2t+32st2+35t3 -48s3+16s2t+3st2-12t3     |
|      -27s3+18s2t-16st2+2t3  44s3+20s2t+8st2-36t3  29s3+23s2t+5st2-30t3      |
|      -11s2+8st-6t2          -15s2-5st-7t2         9s2+41st+44t2             |
|      11s2+46st+39t2         17s2+11st+18t2        -5s2+st-18t2              |
|      20s2+16st+14t2         -33s2-11st+24t2       38s2-st-19t2              |
|      6s2+39st-33t2          -24s2-8st-32t2        -45s2-40st+22t2           |
|      46s2+23st+10t2         -33s2-11st+9t2        -29s2-19st-29t2           |
|      20s2+38st+45t2         4s2+35st+23t2         -11s2-15st-15t2           |
|      0                      0                     0                         |
|      0                      0                     0                         |
|      -----------------------------------------------------------------------|
|      0                     0                      0                         |
|      0                     0                      0                         |
|      49s3+42s2t-19st2+8t3  -12s3+29s2t+33st2+6t3  28s3+8s2t+10st2-23t3      |
|      50s3-47s2t-33st2+43t3 -11s3+13s2t+36st2+29t3 -8s3-12s2t-17st2+46t3     |
|      32s2+11st-30t2        -40s2+15st-43t2        38s2-30st+28t2            |
|      4s2+36st-47t2         27s2-47st+48t2         19s2-17st-42t2            |
|      -5s2-25st-15t2        16s2-27st              42s2-39st-21t2            |
|      6s2-16st+35t2         -42s2-12st-8t2         -49s2+49st-29t2           |
|      -25s2+45st+43t2       -44s2-14st+17t2        24s2-38st-48t2            |
|      -23s2-23st+21t2       -46s2-49st-27t2        22s2+7st-49t2             |
|      0                     0                      0                         |
|      0                     0                      0                         |
|      -----------------------------------------------------------------------|
|      0                            0            |                            |
|      0                            0            |                            |
|      -43s4-5s3t+49s2t2+21st3+15t4 0            |                            |
|      15s4-40s3t-35s2t2-33st3-11t4 0            |                            |
|      16s3-9s2t+26st2-48t3         0            |                            |
|      -32s3+18s2t-20st2+20t3       0            |                            |
|      30s3+2s2t+38st2+11t3         0            |                            |
|      -33s3+29s2t+26st2+3t3        0            |                            |
|      12s3-20s2t+11st2+39t3        0            |                            |
|      23s3+49s2t+9st2+17t3         0            |                            |
|      4s2-4st-12t2                 0            |                            |
|      0                            4s2-4st-12t2 |                            |
|                                                                             |
|                       12               12                                   |
|o14 : Matrix (kk[s, t])   <-- (kk[s, t])                                     |
+-----------------------------------------------------------------------------+

See also
========

  * cliffordModule -- makes a clifford Module
  * cliffordModuleToCIResolution, --
    transforms a Clifford module to a resolution over a complete intersection
    ring
  * cliffordModuleToMatrixFactorization
    -- reads off a matrix factorization
    from a Clifford module
  * ciModuleToMatrixFactorization, --
    transforms a module over a complete intersection of 2 quadrics into a
    matrix factorization
  * ciModuleToCliffordModule -- transforms a
    module over a complete intersection of 2 quadrics into a Clifford Module.

Ways to use ciModuleToCliffordModule:
=====================================

  * "ciModuleToCliffordModule(Module)"

For the programmer
==================

The object ciModuleToCliffordModule, is a
method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:1898:0.

ciModuleToMatrixFactorization -- transforms a module over a complete intersection of 2 quadrics into a matrix factorization
***************************************************************************************************************************

  * Usage:
        (e1,e0) = ciModuleToMatrixFactorization M
  * Inputs:
      * M, a module (Macaulay2Doc), module over a complete
        intersection of 2 quadrics
  * Outputs:
      * e1, a matrix (Macaulay2Doc),
      * e0, a matrix (Macaulay2Doc), the matrix factorization, in
        the form needed for cliffordModule(e1,e0,R)

Description
===========

Part of the series of explicit functors giving category equivalences:

cliffordModule

cliffordModuleToCIResolution

cliffordModuleToMatrixFactorization

ciModuleToMatrixFactorization

ciModuleToCliffordModule

This function uses the bihomogeneous matrix factorization produced by the
script EisenbudShamashTotal in the package CompleteIntersectionResolutions.
Using the multigrading, a new matrix factorization in the form needed for
cliffordModule(e1,e0,R), where R=k[s,t].

+-----------------------------------------------------------------------------+
|i1 : setRandomSeed 0                                                         |
| -- setting random seed to 0                                                 |
|                                                                             |
|o1 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i2 : n = 4                                                                   |
|                                                                             |
|o2 = 4                                                                       |
+-----------------------------------------------------------------------------+
|i3 : c = 2                                                                   |
|                                                                             |
|o3 = 2                                                                       |
+-----------------------------------------------------------------------------+
|i4 : kk = ZZ/101                                                             |
|                                                                             |
|o4 = kk                                                                      |
|                                                                             |
|o4 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i5 : U = kk[x_0..x_(n-1)]                                                    |
|                                                                             |
|o5 = U                                                                       |
|                                                                             |
|o5 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i6 : qq = matrix{{x_0^2+x_1^2,x_0*x_1}}                                      |
|                                                                             |
|o6 = | x_0^2+x_1^2 x_0x_1 |                                                  |
|                                                                             |
|             1      2                                                        |
|o6 : Matrix U  <-- U                                                         |
+-----------------------------------------------------------------------------+
|i7 : qq = random(U^1, U^{2:-2})                                              |
|                                                                             |
|o7 = | 24x_0^2-36x_0x_1+19x_1^2-30x_0x_2+19x_1x_2-29x_2^2-29x_0x_3-10x_1x_3- |
|     ------------------------------------------------------------------------|
|     8x_2x_3-22x_3^2 -29x_0^2-24x_0x_1+39x_1^2-38x_0x_2+21x_1x_2+19x_2^2-16x_|
|     ------------------------------------------------------------------------|
|     0x_3+34x_1x_3-47x_2x_3-39x_3^2 |                                        |
|                                                                             |
|             1      2                                                        |
|o7 : Matrix U  <-- U                                                         |
+-----------------------------------------------------------------------------+
|i8 : Ubar = U/ideal qq                                                       |
|                                                                             |
|o8 = Ubar                                                                    |
|                                                                             |
|o8 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i9 : M = coker vars Ubar                                                     |
|                                                                             |
|o9 = cokernel | x_0 x_1 x_2 x_3 |                                            |
|                                                                             |
|                                  1                                          |
|o9 : Ubar-module, quotient of Ubar                                           |
+-----------------------------------------------------------------------------+
|i10 : betti (fM=freeResolution(M, LengthLimit => n))                         |
|                                                                             |
|             0 1 2  3  4                                                     |
|o10 = total: 1 4 8 12 16                                                     |
|          0: 1 4 8 12 16                                                     |
|                                                                             |
|o10 : BettiTally                                                             |
+-----------------------------------------------------------------------------+
|i11 : betti freeResolution(coker transpose fM.dd_3, LengthLimit => n)        |
|                                                                             |
|              0 1 2 3 4                                                      |
|o11 = total: 12 8 5 5 8                                                      |
|         -3: 12 8 4 1 .                                                      |
|         -2:  . . 1 4 8                                                      |
|                                                                             |
|o11 : BettiTally                                                             |
+-----------------------------------------------------------------------------+
|i12 : (e1,e0) = ciModuleToMatrixFactorization M;                             |
+-----------------------------------------------------------------------------+

Check that it's a matrix factorization:

+-----------------------------------------------------------------------------+
|i13 : source e0 == target e1                                                 |
|                                                                             |
|o13 = true                                                                   |
+-----------------------------------------------------------------------------+
|i14 : 0 == e0*e1 - diagonalMatrix(ring e0, apply(numcols e0, i->(e0*e1)_0_0))|
|                                                                             |
|o14 = true                                                                   |
+-----------------------------------------------------------------------------+
|i15 : degrees source e1-degrees target e0                                    |
|                                                                             |
|o15 = {{3}, {3}, {3}, {3}, {3}, {3}, {3}, {3}}                               |
|                                                                             |
|o15 : List                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * cliffordModule -- makes a clifford Module
  * cliffordModuleToCIResolution, --
    transforms a Clifford module to a resolution over a complete intersection
    ring
  * cliffordModuleToMatrixFactorization
    -- reads off a matrix factorization
    from a Clifford module
  * ciModuleToMatrixFactorization, --
    transforms a module over a complete intersection of 2 quadrics into a
    matrix factorization
  * ciModuleToCliffordModule -- transforms a
    module over a complete intersection of 2 quadrics into a Clifford Module.

Ways to use ciModuleToMatrixFactorization:
==========================================

  * "ciModuleToMatrixFactorization(Module)"

For the programmer
==================

The object ciModuleToMatrixFactorization,
is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:1847:0.

CliffordModule -- hash table holding details of a Clifford module
*****************************************************************

Description
===========

the keys are oddOperators => uOdd', evenOperators => uEv', evenCenter=>c0',
oddCenter => c1', symmetricM => Q, hyperellipticBranchEquation => f

See also
========

  * cliffordModule -- makes a clifford Module

Functions and methods returning an object of class CliffordModule:
==================================================================

  * cliffordModule -- makes a clifford Module

Methods that use an object of class CliffordModule:
===================================================

  * "cliffordModuleToCIResolution(CliffordModule,Ring,Ring)" -- see
    cliffordModuleToCIResolution, -- transforms a
    Clifford module to a resolution over a complete intersection ring
  * "cliffordModuleToMatrixFactorization(CliffordModule,Ring)" -- see
    cliffordModuleToMatrixFactorization,
    -- reads off a matrix factorization from a Clifford module
  * "randomIsotropicSubspace(CliffordModule,PolynomialRing)" -- see
    randomIsotropicSubspace, -- choose a random
    isotropic subspace
  * "searchUlrich(CliffordModule,Ring)" -- see searchUlrich,
    -- searching an Ulrich module of smallest possible rank, or
    an Ulrich module of given rank.
  * "searchUlrich(CliffordModule,Ring,ZZ)" -- see searchUlrich,
    -- searching an Ulrich module of smallest possible rank, or
    an Ulrich module of given rank.
  * "tensorProduct(CliffordModule,VectorBundleOnE)" -- see tensorProduct,
    -- tensor product of sheaves on the elliptic curve or sheaf
    times CliffordModule
  * "translateIsotropicSubspace(CliffordModule,VectorBundleOnE,PolynomialRing)"
    -- see translateIsotropicSubspace, --
    choose a random isotropic subspace

For the programmer
==================

The object CliffordModule, is a type (Macaulay2Doc),
with ancestor classes MutableHashTable (Macaulay2Doc),
< HashTable (Macaulay2Doc) <
Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2085:0.

cliffordModule -- makes a clifford Module
*****************************************

  * Usage:
        M = cliffordModule(M1,M2,R)
        M = cliffordModule(eOdd,eEv)
  * Inputs:
      * M1, a matrix (Macaulay2Doc),
      * M2, a matrix (Macaulay2Doc), M1, M2 a matrix
        factorization of a quadratic form qq
      * R, a ring (Macaulay2Doc), base ring of the quadratic form
      * eEv, a list (Macaulay2Doc),
      * eOdd, a list (Macaulay2Doc), lists such as the output of
        cliffordOperators(M1,M2)
  * Outputs:
      * M, an instance of the type CliffordModule,

Description
===========

The keys oddOperators evenOperators are the same as the two lists output by
cliffordOperators(M1,M2)

The keys evenCenter oddCenter yield the action of the center of the even
Clifford algebra of qq on the even, respectively odd parts of the Clifford
module.

The key symmetricM yields the matrix of coefficients of the quadratic form qq

the key hyperellipticBranchEquation yields the branch equation in R -- that is,
the equation of the set of points over which the quadratic form is singular.

+--------------------------------------------------------------+
|i1 : kk = ZZ/101                                              |
|                                                              |
|o1 = kk                                                       |
|                                                              |
|o1 : QuotientRing                                             |
+--------------------------------------------------------------+
|i2 : setRandomSeed 0                                          |
| -- setting random seed to 0                                  |
|                                                              |
|o2 = 0                                                        |
+--------------------------------------------------------------+
|i3 : g = 1                                                    |
|                                                              |
|o3 = 1                                                        |
+--------------------------------------------------------------+
|i4 : (S, qq,  R,  u, M1, M2, Mu1, Mu2)=randomNicePencil(kk,g);|
+--------------------------------------------------------------+
|i5 : M = cliffordModule(M1,M2, R)                             |
|                                                              |
|o5 = CliffordModule{...6...}                                  |
|                                                              |
|o5 : CliffordModule                                           |
+--------------------------------------------------------------+
|i6 : Mu = cliffordModule(Mu1,Mu2, R)                          |
|                                                              |
|o6 = CliffordModule{...6...}                                  |
|                                                              |
|o6 : CliffordModule                                           |
+--------------------------------------------------------------+

The symmetric matrices are the same for both:

+------------------------------+
|i7 : Mu.symmetricM            |
|                              |
|o7 = | -5t  -50s 6t     -6t  ||
|     | -50s 0    -9t    5t   ||
|     | 6t   -9t  -s-30t 3t   ||
|     | -6t  5t   3t     -48t ||
|                              |
|             4      4         |
|o7 : Matrix R  <-- R          |
+------------------------------+
|i8 : M.symmetricM             |
|                              |
|o8 = | -5t  -50s 6t     -6t  ||
|     | -50s 0    -9t    5t   ||
|     | 6t   -9t  -s-30t 3t   ||
|     | -6t  5t   3t     -48t ||
|                              |
|             4      4         |
|o8 : Matrix R  <-- R          |
+------------------------------+

But the operators are twice the size for M (in both cases the same size as the
corresponding matrix factorization Mu.evenCenter numrows(Mu.evenCenter) ==
numrows(Mu1) M.evenCenter

See also
========

  * matrixFactorizationK -- Knoerrer matrix
    factorization from a bilinear form X*transpose Y
  * cliffordOperators -- Generators for a Clifford
    Algebra

Ways to use cliffordModule:
===========================

  * "cliffordModule(List,List)"
  * "cliffordModule(Matrix,Matrix,Ring)"

For the programmer
==================

The object cliffordModule, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2716:0.

cliffordModuleToCIResolution -- transforms a Clifford module to a resolution over a complete intersection ring
**************************************************************************************************************

  * Usage:
        F=cliffordModuleToCIResolution(M,S,CI)
  * Inputs:
      * M, an instance of the type CliffordModule, a
        Clifford module on a hyperelliptic curve of genus g
      * S, a ring (Macaulay2Doc), a polynomial ring in
        x_0..y_(g-1),z_1,z_2,s,t
      * CI, a ring (Macaulay2Doc), a complete intersection
        S/ideal(q1,q2) where qq=s*q1+t*q2
  * Outputs:
      * F, a complex (Complexes), a resolution which represents
        a module over CI

Description
===========

Part of the series of explicit functors giving category equivalences:

cliffordModule

cliffordModuleToCIResolution

cliffordModuleToMatrixFactorization

ciModuleToMatrixFactorization

ciModuleToCliffordModule

From Clifford module M on the Clifford algebra C:=Cliff(qq) of a quadratic form
qq=s*q1+t*q2, we may construct a module over CI=P/ideal(q1,q2) where P is a
polynomial ring in x_0..y_{(g-1)},z_1,z_2. This function returns a part of its
minimal free resolution over CI. This function uses
cliffordModuleToMatrixFactorization.

+-----------------------------------------------------------------------------+
|i1 : kk=ZZ/101;                                                              |
+-----------------------------------------------------------------------------+
|i2 : setRandomSeed 0                                                         |
| -- setting random seed to 0                                                 |
|                                                                             |
|o2 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i3 : g=1;                                                                    |
+-----------------------------------------------------------------------------+
|i4 : rNP=randNicePencil(kk,g);                                               |
+-----------------------------------------------------------------------------+
|i5 : qq=rNP.quadraticForm;                                                   |
+-----------------------------------------------------------------------------+
|i6 : S=rNP.qqRing;                                                           |
+-----------------------------------------------------------------------------+
|i7 : P=kk[drop(gens S,-2)]                                                   |
|                                                                             |
|o7 = P                                                                       |
|                                                                             |
|o7 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i8 : qs=sub(diff(matrix{{S_(2*g+2), S_(2*g+3)}}, qq), P)                     |
|                                                                             |
|o8 = | x_0y_0-z_1^2 -5x_0^2+12x_0z_1-18y_0z_1-30z_1^2-12x_0z_2+10y_0z_2+6z_1z|
|     ------------------------------------------------------------------------|
|     _2-48z_2^2 |                                                            |
|                                                                             |
|             1      2                                                        |
|o8 : Matrix P  <-- P                                                         |
+-----------------------------------------------------------------------------+
|i9 : CI=P/ideal qs                                                           |
|                                                                             |
|o9 = CI                                                                      |
|                                                                             |
|o9 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i10 : cM=cliffordModule(rNP.matFact1,rNP.matFact2,rNP.baseRing)              |
|                                                                             |
|o10 = CliffordModule{...6...}                                                |
|                                                                             |
|o10 : CliffordModule                                                         |
+-----------------------------------------------------------------------------+
|i11 : betti (F=cliffordModuleToCIResolution(cM,S,CI))                        |
|                                                                             |
|              0  1  2 3 4 5                                                  |
|o11 = total: 20 16 12 8 5 5                                                  |
|          0: 20 16 12 8 4 1                                                  |
|          1:  .  .  . . 1 4                                                  |
|                                                                             |
|o11 : BettiTally                                                             |
+-----------------------------------------------------------------------------+
|i12 : cMu=cliffordModule(rNP.matFactu1,rNP.matFactu2,rNP.baseRing)           |
|                                                                             |
|o12 = CliffordModule{...6...}                                                |
|                                                                             |
|o12 : CliffordModule                                                         |
+-----------------------------------------------------------------------------+
|i13 : f=cMu.hyperellipticBranchEquation                                      |
|                                                                             |
|           3       2 2        3      4                                       |
|o13 = - 12s t - 50s t  - 16s*t  + 47t                                        |
|                                                                             |
|o13 : kk[s, t]                                                               |
+-----------------------------------------------------------------------------+
|i14 : L=randomLineBundle(0,f);                                               |
+-----------------------------------------------------------------------------+
|i15 : betti (FL=cliffordModuleToCIResolution(tensorProduct(cM,L),S,CI))      |
|                                                                             |
|              0 1 2 3 4  5                                                   |
|o15 = total: 12 8 4 4 8 12                                                   |
|         -1: 12 8 4 . .  .                                                   |
|          0:  . . . 4 8 12                                                   |
|                                                                             |
|o15 : BettiTally                                                             |
+-----------------------------------------------------------------------------+
|i16 : betti (FuL=cliffordModuleToCIResolution(tensorProduct(cMu,L),S,CI))    |
|                                                                             |
|             0 1 2 3 4 5                                                     |
|o16 = total: 7 5 3 2 3 5                                                     |
|         -1: 7 5 3 1 . .                                                     |
|          0: . . . 1 3 5                                                     |
|                                                                             |
|o16 : BettiTally                                                             |
+-----------------------------------------------------------------------------+

See also
========

  * cliffordModule -- makes a clifford Module
  * cliffordModuleToMatrixFactorization
    -- reads off a matrix factorization
    from a Clifford module
  * ciModuleToMatrixFactorization, --
    transforms a module over a complete intersection of 2 quadrics into a
    matrix factorization
  * ciModuleToCliffordModule -- transforms a
    module over a complete intersection of 2 quadrics into a Clifford Module.

Ways to use cliffordModuleToCIResolution:
=========================================

  * "cliffordModuleToCIResolution(CliffordModule,Ring,Ring)"

For the programmer
==================

The object cliffordModuleToCIResolution, is
a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:3322:0.

cliffordModuleToMatrixFactorization -- reads off a matrix factorization from a Clifford module
**********************************************************************************************

  * Usage:
        (M1,M2) = cliffordModuleToMatrixFactorization(M,S)
  * Inputs:
      * M, an instance of the type CliffordModule, a
        Clifford module on a hyperelliptic curve E of genus g
      * S, a ring (Macaulay2Doc), a polynomial ring in
        x_0..y_{(g-1)},z_1,z_2,s,t
  * Outputs:
      * M1, a matrix (Macaulay2Doc),
      * M2, a matrix (Macaulay2Doc), (M1, M2) a matrix
        factorization of qq, the equation of the associated pencil of quadrics

Description
===========

Part of the series of explicit functors giving category equivalences:

cliffordModule

cliffordModuleToCIResolution

cliffordModuleToMatrixFactorization

ciModuleToMatrixFactorization

ciModuleToCliffordModule

A Clifford module M on the Clifford algebra C:=Cliff(qq) of a quadratic form qq
has keys evenOperator and oddOperator, the list of the even operators uEv_i :
M_0 \to M_1 and the odd operators uOdd_i : M_1 \to M_0, which form a
representation of C.

From this representation we read off a matrix factorization (M1, M2) of qq.

+------------------------------------------------------------------+
|i1 : kk=ZZ/101;                                                   |
+------------------------------------------------------------------+
|i2 : setRandomSeed 0                                              |
| -- setting random seed to 0                                      |
|                                                                  |
|o2 = 0                                                            |
+------------------------------------------------------------------+
|i3 : g=1;                                                         |
+------------------------------------------------------------------+
|i4 : rNP=randNicePencil(kk,g);                                    |
+------------------------------------------------------------------+
|i5 : qq=rNP.quadraticForm;                                        |
+------------------------------------------------------------------+
|i6 : S=rNP.qqRing;                                                |
+------------------------------------------------------------------+
|i7 : cM=cliffordModule(rNP.matFact1,rNP.matFact2,rNP.baseRing)    |
|                                                                  |
|o7 = CliffordModule{...6...}                                      |
|                                                                  |
|o7 : CliffordModule                                               |
+------------------------------------------------------------------+
|i8 : (M1,M2)=cliffordModuleToMatrixFactorization(cM,S);           |
+------------------------------------------------------------------+
|i9 : r=rank source M1                                             |
|                                                                  |
|o9 = 8                                                            |
+------------------------------------------------------------------+
|i10 : M1*M2 - qq*id_(S^r) == 0                                    |
|                                                                  |
|o10 = true                                                        |
+------------------------------------------------------------------+
|i11 : M1 == rNP.matFact1                                          |
|                                                                  |
|o11 = true                                                        |
+------------------------------------------------------------------+
|i12 : M2 == rNP.matFact2                                          |
|                                                                  |
|o12 = true                                                        |
+------------------------------------------------------------------+
|i13 : cMu=cliffordModule(rNP.matFactu1,rNP.matFactu2,rNP.baseRing)|
|                                                                  |
|o13 = CliffordModule{...6...}                                     |
|                                                                  |
|o13 : CliffordModule                                              |
+------------------------------------------------------------------+
|i14 : (Mu1,Mu2)=cliffordModuleToMatrixFactorization(cMu,S);       |
+------------------------------------------------------------------+
|i15 : ru=rank source Mu1                                          |
|                                                                  |
|o15 = 4                                                           |
+------------------------------------------------------------------+
|i16 : Mu1*Mu2 - qq*id_(S^ru) == 0                                 |
|                                                                  |
|o16 = true                                                        |
+------------------------------------------------------------------+
|i17 : Mu1 == rNP.matFactu1                                        |
|                                                                  |
|o17 = true                                                        |
+------------------------------------------------------------------+
|i18 : Mu2 == rNP.matFactu2                                        |
|                                                                  |
|o18 = true                                                        |
+------------------------------------------------------------------+

See also
========

  * cliffordModule -- makes a clifford Module
  * cliffordModuleToCIResolution, --
    transforms a Clifford module to a resolution over a complete intersection
    ring
  * ciModuleToMatrixFactorization, --
    transforms a module over a complete intersection of 2 quadrics into a
    matrix factorization
  * ciModuleToCliffordModule -- transforms a
    module over a complete intersection of 2 quadrics into a Clifford Module.

Ways to use cliffordModuleToMatrixFactorization:
================================================

  * "cliffordModuleToMatrixFactorization(CliffordModule,Ring)"

For the programmer
==================

The object cliffordModuleToMatrixFactorization,
is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:3260:0.

cliffordOperators -- Generators for a Clifford Algebra
******************************************************

  * Usage:
        (eOdd, eEv) = cliffordOperators (M1,M2,R)
  * Inputs:
      * R, a ring (Macaulay2Doc), polynomial ring of the form
        kk[U], where U are parameter variables
      * M1, a matrix (Macaulay2Doc), over an auxiliary ring S =
        kk[X,Y,Z,U]
      * M2, a matrix (Macaulay2Doc), M1, M2 a matrix
        factorization: M1*M2- qq*id = 0 for a quadratic form qq on S
  * Outputs:
      * eOdd, a list (Macaulay2Doc),
      * eEv, a list (Macaulay2Doc), each list has length n =
        numgens S - numgens R; the elements are matrices of size rank target
        M1.

Description
===========

The Clifford algebra C := Cliff(qq) of a quadratic form qq in n=2d variables is
a free ZZ/2-graded algebra of rank 2^{n} where n = numgens S-numgens R (if R is
ZZ-graded, and M1, M2 are linear in the variables of R, then C inherits a
ZZ-grading; this is our usual case. As an R-module C = C0++C1, with each
component of rank 2^{(n-1)}. The operators eOdd_i go from C1 to C0; the
operators eEv go from C0 to C1.

We have eOdd_i*eEv_j+eOdd_j*eEv_i = B(e_i,e_j), where the e_i form a basis of
the space on which qq acts and B is the bilinear form associated to 2qq thus
the the pairs (eOd_i,eEv_i) form a representation of Cliff(qq).

In the following we construct the generic symmetric bilinear form on 2d
variables and make a quadratic form qq out of it.

+------------------------------------------------+
|i1 : kk=ZZ/101; d=1;                            |
+------------------------------------------------+
|i3 : n=2*d                                      |
|                                                |
|o3 = 2                                          |
+------------------------------------------------+
|i4 : R=kk[a_0..a_(binomial(n+2,2))]             |
|                                                |
|o4 = R                                          |
|                                                |
|o4 : PolynomialRing                             |
+------------------------------------------------+
|i5 : S=kk[x_0..x_(n-1),a_0..a_(binomial(n+2,2))]|
|                                                |
|o5 = S                                          |
|                                                |
|o5 : PolynomialRing                             |
+------------------------------------------------+
|i6 : M=genericSymmetricMatrix(S,a_0,n)          |
|                                                |
|o6 = | a_0 a_1 |                                |
|     | a_1 a_2 |                                |
|                                                |
|             2      2                           |
|o6 : Matrix S  <-- S                            |
+------------------------------------------------+
|i7 : X=(vars S)_{0..n-1}                        |
|                                                |
|o7 = | x_0 x_1 |                                |
|                                                |
|             1      2                           |
|o7 : Matrix S  <-- S                            |
+------------------------------------------------+
|i8 : Y=X*M                                      |
|                                                |
|o8 = | x_0a_0+x_1a_1 x_0a_1+x_1a_2 |            |
|                                                |
|             1      2                           |
|o8 : Matrix S  <-- S                            |
+------------------------------------------------+
|i9 : qq = X*transpose Y                         |
|                                                |
|o9 = | x_0^2a_0+2x_0x_1a_1+x_1^2a_2 |           |
|                                                |
|             1      1                           |
|o9 : Matrix S  <-- S                            |
+------------------------------------------------+
|i10 : (M1,M2)=matrixFactorizationK(X,Y);        |
+------------------------------------------------+
|i11 : (eOdd,eEv)=cliffordOperators(M1,M2,R);    |
+------------------------------------------------+

we check two of the relations of the Clifford algebra:

+------------------------------------------------+
|i12 : (eOdd_0*eEv_0+eOdd_0*eEv_0)_(0,0) == 2*R_0|
|                                                |
|o12 = true                                      |
+------------------------------------------------+
|i13 : (eOdd_0*eEv_1+eOdd_1*eEv_0)_(0,0) == 2*R_1|
|                                                |
|o13 = true                                      |
+------------------------------------------------+

See also
========

  * centers -- even and odd action of the center of the even
    Clifford algebra
  * cliffordModule -- makes a clifford Module

Ways to use cliffordOperators:
==============================

  * "cliffordOperators(Matrix,Matrix,Ring)"

For the programmer
==================

The object cliffordOperators, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2068:0.

degOnE -- degree of a vector bundle on E
****************************************

  * Usage:
        d = degOnE(L)
        d = degOnE(phi)
  * Inputs:
      * L, an instance of the type VectorBundleOnE, a
        vector bundle on E
      * phi, a matrix (Macaulay2Doc), a matrix which is the
        yAction of some VectorBundleOnE
  * Outputs:
      * d, an integer (Macaulay2Doc), the degree of L

Description
===========

Computes the degree of a vector bundle L on the hyperelliptic curve E.

+-----------------------------------------------------------------------------+
|i1 : kk=ZZ/101;                                                              |
+-----------------------------------------------------------------------------+
|i2 : setRandomSeed 0                                                         |
| -- setting random seed to 0                                                 |
|                                                                             |
|o2 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i3 : g=1;                                                                    |
+-----------------------------------------------------------------------------+
|i4 : rNP=randNicePencil(kk,g);                                               |
+-----------------------------------------------------------------------------+
|i5 : f=(cliffordModule(rNP.matFact1,rNP.matFact2,rNP.baseRing)).             |
|-----------------------------------------------------------------------------|
|hyperellipticBranchEquation;                                                 |
+-----------------------------------------------------------------------------+
|i6 : L0=randomLineBundle(0,f)                                                |
|                                                                             |
|o6 = VectorBundleOnE{...1...}                                                |
|                                                                             |
|o6 : VectorBundleOnE                                                         |
+-----------------------------------------------------------------------------+
|i7 : degOnE L0                                                               |
|                                                                             |
|o7 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i8 : L1=randomLineBundle(1,f)                                                |
|                                                                             |
|o8 = VectorBundleOnE{...1...}                                                |
|                                                                             |
|o8 : VectorBundleOnE                                                         |
+-----------------------------------------------------------------------------+
|i9 : degOnE L1                                                               |
|                                                                             |
|o9 = 1                                                                       |
+-----------------------------------------------------------------------------+
|i10 : Lm1=randomLineBundle(-1,f)                                             |
|                                                                             |
|o10 = VectorBundleOnE{...1...}                                               |
|                                                                             |
|o10 : VectorBundleOnE                                                        |
+-----------------------------------------------------------------------------+
|i11 : degOnE Lm1                                                             |
|                                                                             |
|o11 = -1                                                                     |
+-----------------------------------------------------------------------------+

See also
========

  * randomLineBundle -- a random balanced line bundle
    on the hyperelliptic curve
  * vectorBundleOnE -- creates a VectorBundleOnE,
    represented as a matrix factorization
  * VectorBundleOnE -- vector bundle on a hyperelliptic
    curve E
  * yAction -- defines a vector bundle on E
  * degOnE -- degree of a vector bundle on E

Ways to use degOnE:
===================

  * "degOnE(Matrix)"
  * "degOnE(VectorBundleOnE)"

For the programmer
==================

The object degOnE, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2990:0.

evenCenter -- part of a CliffordModule
**************************************

  * Usage:
        c0 = M.evenCenter
  * Outputs:
      * c0, a matrix (Macaulay2Doc),

Description
===========

Gives the action of Haag's center element y of the even Clifford algebra on the
even part of M

+-----------------------------------------------------------------------------+
|i1 : setRandomSeed 0                                                         |
| -- setting random seed to 0                                                 |
|                                                                             |
|o1 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i2 : kk = ZZ/101                                                             |
|                                                                             |
|o2 = kk                                                                      |
|                                                                             |
|o2 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i3 : g = 1                                                                   |
|                                                                             |
|o3 = 1                                                                       |
+-----------------------------------------------------------------------------+
|i4 : (S, qq,  R,  u, M1, M2, Mu1, Mu2)=randomNicePencil(kk,g);               |
+-----------------------------------------------------------------------------+
|i5 : M = cliffordModule(M1,M2, R)                                            |
|                                                                             |
|o5 = CliffordModule{...6...}                                                 |
|                                                                             |
|o5 : CliffordModule                                                          |
+-----------------------------------------------------------------------------+
|i6 : M.evenCenter                                                            |
|                                                                             |
|o6 = {-4} | -49st+24t2 24s2t+13st2 -28st2     5s2t-5st2  -39t3     25st2-25t3|
|     {-3} | 50s        49st+24t2   5st        9st        25t2      45t2      |
|     {-3} | -6t        6st+43t2    -49st-24t2 -50s2+15st 15t2      5st+49t2  |
|     {-3} | 6t         -15t2       -24st      49st-24t2  -38t2     -15t2     |
|     {-3} | 9t         -5st+5t2    0          0          49st-24t2 50s2-15st |
|     {-3} | -5t        -28t2       0          0          24st      -49st-24t2|
|     {-3} | -3t        -48st-26t2  28t2       -5st+5t2   -15t2     -6st-43t2 |
|     {-2} | 1          3t          -5t        -9t        -6t       -6t       |
|     ------------------------------------------------------------------------|
|     0         0            |                                                |
|     0         0            |                                                |
|     -45t2     25st2-25t3   |                                                |
|     25t2      39t3         |                                                |
|     9st       -5s2t+5st2   |                                                |
|     -5st      -28st2       |                                                |
|     49st+24t2 -24s2t-13st2 |                                                |
|     -50s      -49st+24t2   |                                                |
|                                                                             |
|             8      8                                                        |
|o6 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+

See also
========

  * evenOperators -- part of a CliffordModule
  * oddOperators -- part of a CliffordModule
  * oddCenter -- part of a CliffordModule
  * oddCenter -- part of a CliffordModule
  * symMatrix -- part of a CliffordModule
  * hyperellipticBranchEquation -- part of
    a CliffordModule

For the programmer
==================

The object evenCenter, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2191:0.

evenOperators -- part of a CliffordModule
*****************************************

  * Usage:
        uEv = M.evenOperators
  * Outputs:
      * uEv, a list (Macaulay2Doc), of the even operators on M

Description
===========

The list of the even operators uEv_i: M_0\to M_1

+-----------------------------------------------------------------------------+
|i1 : setRandomSeed 0                                                         |
| -- setting random seed to 0                                                 |
|                                                                             |
|o1 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i2 : kk = ZZ/101                                                             |
|                                                                             |
|o2 = kk                                                                      |
|                                                                             |
|o2 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i3 : g = 1                                                                   |
|                                                                             |
|o3 = 1                                                                       |
+-----------------------------------------------------------------------------+
|i4 : (S, qq,  R,  u, M1, M2, Mu1, Mu2)=randomNicePencil(kk,g);               |
+-----------------------------------------------------------------------------+
|i5 : M = cliffordModule(M1,M2, R)                                            |
|                                                                             |
|o5 = CliffordModule{...6...}                                                 |
|                                                                             |
|o5 : CliffordModule                                                          |
+-----------------------------------------------------------------------------+
|i6 : M.evenOperators                                                         |
|                                                                             |
|o6 = {{-1} | 0  0  0 -1 0  0   0  0  |, {-1} | 0  0  0 0 0  -1 0  0  |, {-1} |
|      {-1} | 0  0  1 0  0  0   0  0  |  {-1} | 0  0  0 0 1  0  0  0  |  {-1} |
|      {-1} | 0  -1 0 0  0  0   0  0  |  {-1} | 0  0  0 0 0  0  0  0  |  {-1} |
|      {-1} | 0  0  0 0  0  0   0  5t |  {-1} | 0  -1 0 0 0  0  0  -s |  {-1} |
|      {-2} | -1 0  0 0  0  0   0  0  |  {-2} | 0  0  0 0 0  0  0  0  |  {-2} |
|      {-2} | 0  0  0 0  0  0   5t 0  |  {-2} | -1 0  0 0 0  0  -s 0  |  {-2} |
|      {-2} | 0  0  0 0  0  -5t 0  0  |  {-2} | 0  0  0 0 0  s  0  0  |  {-2} |
|      {-2} | 0  0  0 0  5t 0   0  0  |  {-2} | 0  0  0 0 -s 0  0  0  |  {-2} |
|     ------------------------------------------------------------------------|
|     | 0  0     0    0      0    0     -1   0     |, {-1} | 0  0    0   0    |
|     | 0  0     0    0      0    0     0    s+30t |  {-1} | 0  0    0   0    |
|     | 0  0     0    0      1    0     0    -18t  |  {-1} | 0  0    0   0    |
|     | 0  0     -1   0      0    0     0    -12t  |  {-1} | 0  0    0   -1   |
|     | 0  0     0    0      0    s+30t -18t 0     |  {-2} | 0  0    0   0    |
|     | 0  0     0    -s-30t 0    0     -12t 0     |  {-2} | 0  0    48t 6t   |
|     | -1 0     0    18t    0    12t   0    0     |  {-2} | 0  -48t 0   -10t |
|     | 0  s+30t -18t 0      -12t 0     0    0     |  {-2} | -1 -6t  10t 0    |
|     ------------------------------------------------------------------------|
|     0    0    0   -48t |}                                                   |
|     0    0    -1  -6t  |                                                    |
|     0    1    0   10t  |                                                    |
|     0    0    0   12t  |                                                    |
|     -48t -6t  10t 0    |                                                    |
|     0    0    12t 0    |                                                    |
|     0    -12t 0   0    |                                                    |
|     12t  0    0   0    |                                                    |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * oddOperators -- part of a CliffordModule
  * evenCenter -- part of a CliffordModule
  * oddCenter -- part of a CliffordModule
  * symMatrix -- part of a CliffordModule
  * hyperellipticBranchEquation -- part of
    a CliffordModule

For the programmer
==================

The object evenOperators, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2137:0.

hyperellipticBranchEquation -- part of a CliffordModule
*******************************************************

  * Usage:
        f = M.hyperellipticBranchEquation
  * Outputs:
      * f, a ring element (Macaulay2Doc),

Description
===========

Gives the branch equation of the set of points over which the associated
quadratic form is singular. It is same as the determinant of the symmetric
matrix M.symmetricM.

+-------------------------------------------------------------+
|i1 : setRandomSeed 0                                         |
| -- setting random seed to 0                                 |
|                                                             |
|o1 = 0                                                       |
+-------------------------------------------------------------+
|i2 : kk=ZZ/101;                                              |
+-------------------------------------------------------------+
|i3 : g=1;                                                    |
+-------------------------------------------------------------+
|i4 : rNP=randNicePencil(kk,g);                               |
+-------------------------------------------------------------+
|i5 : M=cliffordModule(rNP.matFact1,rNP.matFact2,rNP.baseRing)|
|                                                             |
|o5 = CliffordModule{...6...}                                 |
|                                                             |
|o5 : CliffordModule                                          |
+-------------------------------------------------------------+
|i6 : f=M.hyperellipticBranchEquation                         |
|                                                             |
|          3       2 2        3      4                        |
|o6 = - 12s t - 50s t  - 16s*t  + 47t                         |
|                                                             |
|o6 : kk[s, t]                                                |
+-------------------------------------------------------------+
|i7 : sM=M.symmetricM                                         |
|                                                             |
|o7 = | -5t  -50s 6t     -6t  |                               |
|     | -50s 0    -9t    5t   |                               |
|     | 6t   -9t  -s-30t 3t   |                               |
|     | -6t  5t   3t     -48t |                               |
|                                                             |
|                      4               4                      |
|o7 : Matrix (kk[s, t])  <-- (kk[s, t])                       |
+-------------------------------------------------------------+
|i8 : f == det sM                                             |
|                                                             |
|o8 = true                                                    |
+-------------------------------------------------------------+

See also
========

  * evenOperators -- part of a CliffordModule
  * oddOperators -- part of a CliffordModule
  * oddCenter -- part of a CliffordModule
  * evenCenter -- part of a CliffordModule
  * symmetricM -- part of a CliffordModule

For the programmer
==================

The object hyperellipticBranchEquation, is a
symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2355:0.

isotropicSpace -- part of a RandomNicePencil
********************************************

  * Usage:
        u = rNP.isotropicSpace
  * Outputs:
      * u, a matrix (Macaulay2Doc), 1 x (g+2) row matrix with
        entries x_0 .. x_{(g-1)}, z_1, z_2

Description
===========

a row matrix whose entries are generators of the ideal of an isotropic subspace
for qq.

+-----------------------------------------------------------------------+
|i1 : kk=ZZ/101;                                                        |
+-----------------------------------------------------------------------+
|i2 : setRandomSeed 0                                                   |
| -- setting random seed to 0                                           |
|                                                                       |
|o2 = 0                                                                 |
+-----------------------------------------------------------------------+
|i3 : g=1;                                                              |
+-----------------------------------------------------------------------+
|i4 : rNP=randNicePencil(kk,g);                                         |
+-----------------------------------------------------------------------+
|i5 : u=rNP.isotropicSpace                                              |
|                                                                       |
|o5 = | x_0 z_1 z_2 |                                                   |
|                                                                       |
|                                      1                               3|
|o5 : Matrix (kk[x , y , z ..z , s, t])  <-- (kk[x , y , z ..z , s, t]) |
|                 0   0   1   2                   0   0   1   2         |
+-----------------------------------------------------------------------+

See also
========

  * qqRing -- part of a RandomNicePencil
  * baseRing of a RandomNicePencil, --
    part of a RandomNicePencil
  * quadraticForm -- part of a RandomNicePencil
  * matFact1 -- part of a RandomNicePencil
  * matFact2 -- part of a RandomNicePencil
  * matFactu1 -- part of a RandomNicePencil
  * matFactu2 -- part of a RandomNicePencil

For the programmer
==================

The object isotropicSpace, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2478:0.

LabBookProtocol -- Print commands that lead to a construction of a Ulrich bundle
********************************************************************************

  * Usage:
        S = LabBookProtocol(g)
        S = LabBookProtocol(g,r)
  * Inputs:
      * g, an integer (Macaulay2Doc), genus of the associated
        hyperelliptic curve E.
      * r, an integer (Macaulay2Doc), rank of the vextor bundle E
  * Outputs:
      * S, a string (Macaulay2Doc), of commands which would
        produce an Ulrich bundle on X

Description
===========

Our function searchUlrich produces Ulrich bundles of rank r in principle.
However some of the computation take lot of time. We break this approach for
small (g,r) into parts and protocol the commande and the timings.

+-----------------------------------------------------------------------------+
|i1 : g=3                                                                     |
|                                                                             |
|o1 = 3                                                                       |
+-----------------------------------------------------------------------------+
|i2 : LabBookProtocol(g)                                                      |
|                                                                             |
|            g=3                                                              |
|            kk= ZZ/101;                                                      |
|            elapsedTime (S,qq,R,u, M1,M2, Mu1, Mu2)=randomNicePencil(kk,g);  |
|             -- 0.644455 seconds elapsed                                     |
|            M=cliffordModule(Mu1,Mu2,R)                                      |
|            Mor = vectorBundleOnE M.evenCenter;                              |
|            Mor1= vectorBundleOnE M.oddCenter;                               |
|            f = M.hyperellipticBranchEquation;                               |
|            assert(dim ideal jacobian ideal f ==0);                          |
|            elapsedTime while (                                              |
|                m1=randomLineBundle(g+(g%2),f);                              |
|                m2=randomLineBundle(g%2,f);                                  |
|                m12=randomExtension(m1.yAction,m2.yAction);                  |
|                V = vectorBundleOnE m12;                                     |
|                Ul=tensorProduct(Mor,V);                                     |
|                Ul1=tensorProduct(Mor1,V);                                   |
|                d0=unique degrees target Ul.yAction;                         |
|                d1=unique degrees target Ul1.yAction;                        |
|                #d1 >=3 or #d0 >=3) do ();                                   |
|            -- 0.337555 seconds elapsed                                      |
|            betti Ul.yAction, betti Ul1.yAction                              |
|            --further commands                                               |
|            elapsedTime Ul = tensorProduct(M,V); -- the heaviest part computi|
|            -- 9.35977 seconds elapsed                                       |
|            M1Ul=sum(#Ul.oddOperators,i->S_i*sub(Ul.oddOperators_i,S));      |
|            r=2                                                              |
|            Ulrich := M1Ul^{r*2^g..(2*r)*2^g-1};                             |
|            Ulr=coker map(S^(r*2^g),,Ulrich);                                |
|            minimalBetti Ulr                                                 |
|            -- will give an Ulrich bundle, with betti table                  |
|            -- 16 32 16                                                      |
|-----------------------------------------------------------------------------|
|ng the actions of generators                                                 |
+-----------------------------------------------------------------------------+
|i3 : g=3                                                                     |
|                                                                             |
|o3 = 3                                                                       |
+-----------------------------------------------------------------------------+
|i4 : kk= ZZ/101;                                                             |
+-----------------------------------------------------------------------------+
|i5 : elapsedTime (S,qq,R,u, M1,M2, Mu1, Mu2)=randomNicePencil(kk,g);         |
| -- 2.06973s elapsed                                                         |
+-----------------------------------------------------------------------------+
|i6 : M=cliffordModule(Mu1,Mu2,R)                                             |
|                                                                             |
|o6 = CliffordModule{...6...}                                                 |
|                                                                             |
|o6 : CliffordModule                                                          |
+-----------------------------------------------------------------------------+
|i7 : Mor = vectorBundleOnE M.evenCenter;                                     |
+-----------------------------------------------------------------------------+
|i8 : Mor1= vectorBundleOnE M.oddCenter;                                      |
+-----------------------------------------------------------------------------+
|i9 : f = M.hyperellipticBranchEquation;                                      |
+-----------------------------------------------------------------------------+
|i10 : assert(dim ideal jacobian ideal f ==0);                                |
+-----------------------------------------------------------------------------+
|i11 : elapsedTime while (                                                    |
|          m1=randomLineBundle(g+(g%2),f);                                    |
|          m2=randomLineBundle(g%2,f);                                        |
|          m12=randomExtension(m1.yAction,m2.yAction);                        |
|          V = vectorBundleOnE m12;                                           |
|          Ul=tensorProduct(Mor,V);                                           |
|          Ul1=tensorProduct(Mor1,V);                                         |
|          d0=unique degrees target Ul.yAction;                               |
|          d1=unique degrees target Ul1.yAction;                              |
|          #d1 >=3 or #d0 >=3) do ();                                         |
| -- .640444s elapsed                                                         |
+-----------------------------------------------------------------------------+
|i12 : betti Ul.yAction, betti Ul1.yAction                                    |
|                                                                             |
|               0  1          0  1                                            |
|o12 = (total: 32 32, total: 32 32)                                           |
|          -4: 16  .     -2: 32  .                                            |
|          -3: 16  .     -1:  .  .                                            |
|          -2:  .  .      0:  .  .                                            |
|          -1:  . 16      1:  . 32                                            |
|           0:  . 16                                                          |
|                                                                             |
|o12 : Sequence                                                               |
+-----------------------------------------------------------------------------+
|i13 : elapsedTime Ul = tensorProduct(M,V); -- the heaviest part computing the|
| -- 36.7682s elapsed                                                         |
|-----------------------------------------------------------------------------|
|actions of generators                                                        |
+-----------------------------------------------------------------------------+
|i14 : M1Ul=sum(#Ul.oddOperators,i->S_i*sub(Ul.oddOperators_i,S));            |
|                                                                             |
|              32      32                                                     |
|o14 : Matrix S   <-- S                                                       |
+-----------------------------------------------------------------------------+
|i15 : r=2                                                                    |
|                                                                             |
|o15 = 2                                                                      |
+-----------------------------------------------------------------------------+
|i16 : Ulrich := M1Ul^{r*2^g..(2*r)*2^g-1};                                   |
|                                                                             |
|              16      32                                                     |
|o16 : Matrix S   <-- S                                                       |
+-----------------------------------------------------------------------------+
|i17 : Ulr=coker map(S^(r*2^g),,Ulrich);                                      |
+-----------------------------------------------------------------------------+
|i18 : minimalBetti Ulr                                                       |
|                                                                             |
|              0  1  2                                                        |
|o18 = total: 16 32 16                                                        |
|          0: 16 32 16                                                        |
|                                                                             |
|o18 : BettiTally                                                             |
+-----------------------------------------------------------------------------+
|i19 : (g,r)=(3,4)                                                            |
|                                                                             |
|o19 = (3, 4)                                                                 |
|                                                                             |
|o19 : Sequence                                                               |
+-----------------------------------------------------------------------------+
|i20 : LabBookProtocol(g,r)                                                   |
|                                                                             |
|    g=3                                                                      |
|    r=4                                                                      |
|    kk= ZZ/101;                                                              |
|    elapsedTime (S,qq,R,u, M1,M2, Mu1, Mu2)=randomNicePencil(kk,g);          |
|    -- 0.623928 seconds elapsed                                              |
|     P=kk[drop(gens S,-2)]                                                   |
|    gens P                                                                   |
|    M=cliffordModule(Mu1,Mu2,R)                                              |
|    Mor = vectorBundleOnE M.evenCenter;                                      |
|    Mor1= vectorBundleOnE M.oddCenter;                                       |
|    f = M.hyperellipticBranchEquation;                                       |
|    assert(dim ideal jacobian ideal f ==0);                                  |
|    degSeq={1,2,3,4}                                                         |
|    elapsedTime while (                                                      |
|        -- build a vector bundle V as extensions of line bundles of degrees  |
|        V=randomLineBundle(degSeq#0,f);                                      |
|        for i from 1 to r-1 do(                                              |
|            m1=randomLineBundle(degSeq#i,f);                                 |
|            m12=randomExtension(m1.yAction,V.yAction);                       |
|            V=vectorBundleOnE m12;                                           |
|            );                                                               |
|        Ul=tensorProduct(Mor,V);                                             |
|        Ul1=tensorProduct(Mor1,V);                                           |
|        d0=unique degrees target Ul.yAction;                                 |
|        d1=unique degrees target Ul1.yAction;                                |
|        #d1 >=3 or #d0 >=3) do ();                                           |
|    -- 1.15312 seconds elapsed                                               |
|    betti Ul.yAction,betti Ul1.yAction                                       |
|    --further commands                                                       |
|    elapsedTime Ul = tensorProduct(M,V); -- the heaviest part computing the  |
|    -- 87.5896 seconds elapsed                                               |
|    M1Ul=sum(#Ul.oddOperators,i->S_i*sub(Ul.oddOperators_i,S));              |
|    Ulrich = coker map(P^(r*2^g),,sub(M1Ul^{r*2^g..(2*r)*2^g-1},P));         |
|    minimalBetti Ulrich                                                      |
|    -- Is an Ulrich bundle, with betti numbers                               |
|    -- r*2^g,(2*r)*2^g,r*2^g                                                 |
|    elapsedTime qs=ann Ulrich                                                |
|     -- 25.3661 seconds elapsed                                              |
|    ideal sub(diff((vars S)_{2*g+2,2*g+3},qq),P)==qs                         |
|                                                                             |
|-----------------------------------------------------------------------------|
|in degSeq                                                                    |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|actions of generators                                                        |
+-----------------------------------------------------------------------------+

See also
========

  * searchUlrich -- searching an Ulrich module of smallest
    possible rank, or an Ulrich module of given rank.
  * RandomNicePencil -- hash table holding details of
    a random pencil of quadrics
  * tensorProduct -- tensor product of sheaves on the
    elliptic curve or sheaf times CliffordModule
  * randomLineBundle -- a random balanced line bundle
    on the hyperelliptic curve

Ways to use LabBookProtocol:
============================

  * "LabBookProtocol(ZZ)"
  * "LabBookProtocol(ZZ,ZZ)"

For the programmer
==================

The object LabBookProtocol, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:3458:0.

matFact1 -- part of a RandomNicePencil
**************************************

  * Usage:
        M1 = rNP.matFact1
  * Outputs:
      * M1, a matrix (Macaulay2Doc), a matrix over S such that
        (M1, M2) gives a matrix factorization of qq of size 2^{2g+1}.

Description
===========

M1, M2 are consecutive high syzygy matrices in the minimal periodic resolution
of the base ring R=S/(ideal matrix x_0..y_{(g-1)},z_1,z_2) as a module over
S/(ideal qq). These are used to construct the Clifford algebra of qq.

+----------------------------------+
|i1 : setRandomSeed 0              |
| -- setting random seed to 0      |
|                                  |
|o1 = 0                            |
+----------------------------------+
|i2 : kk=ZZ/101;                   |
+----------------------------------+
|i3 : g=1;                         |
+----------------------------------+
|i4 : rNP=randNicePencil(kk,g);    |
+----------------------------------+
|i5 : S=rNP.qqRing;                |
+----------------------------------+
|i6 : qq=rNP.quadraticForm;        |
+----------------------------------+
|i7 : M1=rNP.matFact1;             |
|                                  |
|             8      8             |
|o7 : Matrix S  <-- S              |
+----------------------------------+
|i8 : M2=rNP.matFact2;             |
|                                  |
|             8      8             |
|o8 : Matrix S  <-- S              |
+----------------------------------+
|i9 : M1*M2 - qq*id_(S^(2^(2*g+1)))|
|                                  |
|o9 = 0                            |
|                                  |
|             8      8             |
|o9 : Matrix S  <-- S              |
+----------------------------------+
|i10 : M1*M2 - M2*M1               |
|                                  |
|o10 = 0                           |
|                                  |
|              8      8            |
|o10 : Matrix S  <-- S             |
+----------------------------------+

See also
========

  * qqRing -- part of a RandomNicePencil
  * baseRing of a RandomNicePencil, --
    part of a RandomNicePencil
  * quadraticForm -- part of a RandomNicePencil
  * matFact2 -- part of a RandomNicePencil
  * matFactu1 -- part of a RandomNicePencil
  * matFactu2 -- part of a RandomNicePencil
  * isotropicSpace -- part of a RandomNicePencil

For the programmer
==================

The object matFact1, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2515:0.

matFact2 -- part of a RandomNicePencil
**************************************

  * Usage:
        M2 = rNP.matFact2
  * Outputs:
      * M2, a matrix (Macaulay2Doc), a matrix over S such that
        (M1, M2) gives a matrix factorization of qq of size 2^{2g+1}.

Description
===========

M1, M2 are consecutive high syzygy matrices in the minimal periodic resolution
of the base ring R=S/(ideal matrix x_0..y_{(g-1)},z_1,z_2) as a module over
S/(ideal qq). These are used to construct the Clifford algebra of qq.

+----------------------------------+
|i1 : setRandomSeed 0              |
| -- setting random seed to 0      |
|                                  |
|o1 = 0                            |
+----------------------------------+
|i2 : kk=ZZ/101;                   |
+----------------------------------+
|i3 : g=1;                         |
+----------------------------------+
|i4 : rNP=randNicePencil(kk,g);    |
+----------------------------------+
|i5 : S=rNP.qqRing;                |
+----------------------------------+
|i6 : qq=rNP.quadraticForm;        |
+----------------------------------+
|i7 : M1=rNP.matFact1;             |
|                                  |
|             8      8             |
|o7 : Matrix S  <-- S              |
+----------------------------------+
|i8 : M2=rNP.matFact2;             |
|                                  |
|             8      8             |
|o8 : Matrix S  <-- S              |
+----------------------------------+
|i9 : M1*M2 - qq*id_(S^(2^(2*g+1)))|
|                                  |
|o9 = 0                            |
|                                  |
|             8      8             |
|o9 : Matrix S  <-- S              |
+----------------------------------+
|i10 : M1*M2 - M2*M1               |
|                                  |
|o10 = 0                           |
|                                  |
|              8      8            |
|o10 : Matrix S  <-- S             |
+----------------------------------+

See also
========

  * qqRing -- part of a RandomNicePencil
  * baseRing of a RandomNicePencil, --
    part of a RandomNicePencil
  * quadraticForm -- part of a RandomNicePencil
  * matFact1 -- part of a RandomNicePencil
  * matFactu1 -- part of a RandomNicePencil
  * matFactu2 -- part of a RandomNicePencil
  * isotropicSpace -- part of a RandomNicePencil

For the programmer
==================

The object matFact2, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2552:0.

matFactu1 -- part of a RandomNicePencil
***************************************

  * Usage:
        Mu1 = rNP.matFactu1
  * Outputs:
      * Mu1, a matrix (Macaulay2Doc), a matrix over S such that
        (Mu1, Mu2) gives a matrix factorization of qq of size 2^{g+1}

Description
===========

Mu1, Mu2 are consecutive high syzygy matrices in the minimal periodic
resolution of the isotropic subspace S/(ideal u) as a module over S/(ideal qq).
These are used to construct a Morita bundle between the even Clifford algebra
of qq and the hyperelliptic curve branched over the degeneracy locus of the
pencil.

+----------------------------------+
|i1 : kk=ZZ/101;                   |
+----------------------------------+
|i2 : setRandomSeed 0              |
| -- setting random seed to 0      |
|                                  |
|o2 = 0                            |
+----------------------------------+
|i3 : g=1;                         |
+----------------------------------+
|i4 : rNP=randNicePencil(kk,g);    |
+----------------------------------+
|i5 : S=rNP.qqRing;                |
+----------------------------------+
|i6 : qq=rNP.quadraticForm;        |
+----------------------------------+
|i7 : Mu1=rNP.matFactu1;           |
|                                  |
|             4      4             |
|o7 : Matrix S  <-- S              |
+----------------------------------+
|i8 : Mu2=rNP.matFactu2;           |
|                                  |
|             4      4             |
|o8 : Matrix S  <-- S              |
+----------------------------------+
|i9 : Mu1*Mu2 - qq*id_(S^(2^(g+1)))|
|                                  |
|o9 = 0                            |
|                                  |
|             4      4             |
|o9 : Matrix S  <-- S              |
+----------------------------------+
|i10 : Mu1*Mu2 - Mu2*Mu1           |
|                                  |
|o10 = 0                           |
|                                  |
|              4      4            |
|o10 : Matrix S  <-- S             |
+----------------------------------+

See also
========

  * qqRing -- part of a RandomNicePencil
  * baseRing of a RandomNicePencil, --
    part of a RandomNicePencil
  * quadraticForm -- part of a RandomNicePencil
  * matFact1 -- part of a RandomNicePencil
  * matFact2 -- part of a RandomNicePencil
  * matFactu2 -- part of a RandomNicePencil
  * isotropicSpace -- part of a RandomNicePencil

For the programmer
==================

The object matFactu1, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2590:0.

matFactu2 -- part of a RandomNicePencil
***************************************

  * Usage:
        Mu2 = rNP.matFactu2
  * Outputs:
      * Mu2, a matrix (Macaulay2Doc), a matrix over S such that
        (Mu1, Mu2) gives a matrix factorization of qq of size 2^{g+1}

Description
===========

Mu1, Mu2 are consecutive high syzygy matrices in the minimal periodic
resolution of the isotropic subspace S/(ideal u) as a module over S/(ideal qq).
These are used to construct a Morita bundle between the even Clifford algebra
of qq and the hyperelliptic curve branched over the degeneracy locus of the
pencil.

+----------------------------------+
|i1 : kk=ZZ/101;                   |
+----------------------------------+
|i2 : setRandomSeed 0              |
| -- setting random seed to 0      |
|                                  |
|o2 = 0                            |
+----------------------------------+
|i3 : g=1;                         |
+----------------------------------+
|i4 : rNP=randNicePencil(kk,g);    |
+----------------------------------+
|i5 : S=rNP.qqRing;                |
+----------------------------------+
|i6 : qq=rNP.quadraticForm;        |
+----------------------------------+
|i7 : Mu1=rNP.matFactu1;           |
|                                  |
|             4      4             |
|o7 : Matrix S  <-- S              |
+----------------------------------+
|i8 : Mu2=rNP.matFactu2;           |
|                                  |
|             4      4             |
|o8 : Matrix S  <-- S              |
+----------------------------------+
|i9 : Mu1*Mu2 - qq*id_(S^(2^(g+1)))|
|                                  |
|o9 = 0                            |
|                                  |
|             4      4             |
|o9 : Matrix S  <-- S              |
+----------------------------------+
|i10 : Mu1*Mu2 - Mu2*Mu1           |
|                                  |
|o10 = 0                           |
|                                  |
|              4      4            |
|o10 : Matrix S  <-- S             |
+----------------------------------+

See also
========

  * qqRing -- part of a RandomNicePencil
  * baseRing of a RandomNicePencil, --
    part of a RandomNicePencil
  * quadraticForm -- part of a RandomNicePencil
  * matFact1 -- part of a RandomNicePencil
  * matFact2 -- part of a RandomNicePencil
  * matFactu1 -- part of a RandomNicePencil
  * isotropicSpace -- part of a RandomNicePencil

For the programmer
==================

The object matFactu2, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2628:0.

matrixFactorizationK -- Knoerrer matrix factorization from a bilinear form X*transpose Y
****************************************************************************************

  * Usage:
        (M1, M2) = matrixFactorizationK(X,Y)
  * Inputs:
      * X, a matrix (Macaulay2Doc), row matrix of linear forms
        with constant coefficients
      * Y, a matrix (Macaulay2Doc), row matrix of linear forms
        with linear coefficients of same length as X
  * Outputs:
      * M1, a matrix (Macaulay2Doc),
      * M2, a matrix (Macaulay2Doc),

Description
===========

Produces a matrix factorization (M1,M2) of the bilinear form X*transpose Y. It
does this by specializing the formula given by Knoerrer  for $\sum X_i*Y_i$.

+------------------------------------------------------------------------+
|i1 : kk=ZZ/101                                                          |
|                                                                        |
|o1 = kk                                                                 |
|                                                                        |
|o1 : QuotientRing                                                       |
+------------------------------------------------------------------------+
|i2 : n=2                                                                |
|                                                                        |
|o2 = 2                                                                  |
+------------------------------------------------------------------------+
|i3 : R=kk[a_0..a_(binomial(n+2,2))]                                     |
|                                                                        |
|o3 = R                                                                  |
|                                                                        |
|o3 : PolynomialRing                                                     |
+------------------------------------------------------------------------+
|i4 : S=kk[x_0..x_(n-1),a_0..a_(binomial(n+2,2))]                        |
|                                                                        |
|o4 = S                                                                  |
|                                                                        |
|o4 : PolynomialRing                                                     |
+------------------------------------------------------------------------+
|i5 : M=genericSymmetricMatrix(S,a_0,n)                                  |
|                                                                        |
|o5 = | a_0 a_1 |                                                        |
|     | a_1 a_2 |                                                        |
|                                                                        |
|             2      2                                                   |
|o5 : Matrix S  <-- S                                                    |
+------------------------------------------------------------------------+
|i6 : X=(vars S)_{0..n-1}                                                |
|                                                                        |
|o6 = | x_0 x_1 |                                                        |
|                                                                        |
|             1      2                                                   |
|o6 : Matrix S  <-- S                                                    |
+------------------------------------------------------------------------+
|i7 : Y=X*M                                                              |
|                                                                        |
|o7 = | x_0a_0+x_1a_1 x_0a_1+x_1a_2 |                                    |
|                                                                        |
|             1      2                                                   |
|o7 : Matrix S  <-- S                                                    |
+------------------------------------------------------------------------+
|i8 : (M1,M2)=matrixFactorizationK(X,Y)                                  |
|                                                                        |
|o8 = ({1} | -x_0          -x_1           |, {2} | -x_0a_0-x_1a_1 x_1  |)|
|      {0} | x_0a_1+x_1a_2 -x_0a_0-x_1a_1 |  {2} | -x_0a_1-x_1a_2 -x_0 | |
|                                                                        |
|o8 : Sequence                                                           |
+------------------------------------------------------------------------+
|i9 : M12=M1*M2                                                          |
|                                                                        |
|o9 = {1} | x_0^2a_0+2x_0x_1a_1+x_1^2a_2 0                            |  |
|     {0} | 0                            x_0^2a_0+2x_0x_1a_1+x_1^2a_2 |  |
|                                                                        |
|             2      2                                                   |
|o9 : Matrix S  <-- S                                                    |
+------------------------------------------------------------------------+

Ways to use matrixFactorizationK:
=================================

  * "matrixFactorizationK(Matrix,Matrix)"

For the programmer
==================

The object matrixFactorizationK, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:1784:0.

oddCenter -- part of a CliffordModule
*************************************

  * Usage:
        c1 = M.oddCenter
  * Outputs:
      * c1, a matrix (Macaulay2Doc),

Description
===========

Gives the action of Haag's center element y of the even Clifford algebra on the
odd part of M

+-----------------------------------------------------------------------------+
|i1 : setRandomSeed 0                                                         |
| -- setting random seed to 0                                                 |
|                                                                             |
|o1 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i2 : kk = ZZ/101                                                             |
|                                                                             |
|o2 = kk                                                                      |
|                                                                             |
|o2 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i3 : g = 1                                                                   |
|                                                                             |
|o3 = 1                                                                       |
+-----------------------------------------------------------------------------+
|i4 : (S, qq,  R,  u, M1, M2, Mu1, Mu2)=randomNicePencil(kk,g);               |
+-----------------------------------------------------------------------------+
|i5 : M = cliffordModule(M1,M2, R)                                            |
|                                                                             |
|o5 = CliffordModule{...6...}                                                 |
|                                                                             |
|o5 : CliffordModule                                                          |
+-----------------------------------------------------------------------------+
|i6 : M.oddCenter                                                             |
|                                                                             |
|o6 = {-1} | -49st+24t2  -24st     15t2         28t2        -6t               |
|     {-1} | -50s2+15st  49st+24t2 6st+43t2     -5st+5t2    -6t               |
|     {-1} | -9st        5st       -49st-24t2   0           -50s              |
|     {-1} | -45t2       25t2      15t2         49st-24t2   5t                |
|     {-2} | -5s2t+5st2  -28st2    -24s2t-13st2 0           49st-24t2         |
|     {-2} | -25st2+25t3 -39t3     -38st2-29t3  24s2t+13st2 -15t2             |
|     {-2} | 0           0         39t3         -28st2      25t2              |
|     {-2} | 0           0         -25st2+25t3  5s2t-5st2   45t2              |
|     ------------------------------------------------------------------------|
|     5t         3t        -48t       |                                       |
|     9t         s+30t     -3t        |                                       |
|     0          -9t       5t         |                                       |
|     50s        -6t       6t         |                                       |
|     0          -5st+5t2  -28t2      |                                       |
|     -49st-24t2 -6st-43t2 15t2       |                                       |
|     -5st       49st+24t2 24st       |                                       |
|     -9st       50s2-15st -49st+24t2 |                                       |
|                                                                             |
|             8      8                                                        |
|o6 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+

See also
========

  * evenOperators -- part of a CliffordModule
  * oddOperators -- part of a CliffordModule
  * oddCenter -- part of a CliffordModule
  * oddCenter -- part of a CliffordModule
  * symMatrix -- part of a CliffordModule
  * hyperellipticBranchEquation -- part of
    a CliffordModule

For the programmer
==================

The object oddCenter, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2251:0.

oddOperators -- part of a CliffordModule
****************************************

  * Usage:
        uOdd = M.oddOperators
  * Outputs:
      * uOdd, a list (Macaulay2Doc), of the odd operators on M

Description
===========

The list of the odd operators uOdd_i: M_1\to M_0

+-----------------------------------------------------------------------------+
|i1 : setRandomSeed 0                                                         |
| -- setting random seed to 0                                                 |
|                                                                             |
|o1 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i2 : kk = ZZ/101                                                             |
|                                                                             |
|o2 = kk                                                                      |
|                                                                             |
|o2 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i3 : g = 1                                                                   |
|                                                                             |
|o3 = 1                                                                       |
+-----------------------------------------------------------------------------+
|i4 : (S, qq,  R,  u, M1, M2, Mu1, Mu2)=randomNicePencil(kk,g);               |
+-----------------------------------------------------------------------------+
|i5 : M = cliffordModule(M1,M2, R)                                            |
|                                                                             |
|o5 = CliffordModule{...6...}                                                 |
|                                                                             |
|o5 : CliffordModule                                                          |
+-----------------------------------------------------------------------------+
|i6 : M.oddOperators                                                          |
|                                                                             |
|o6 = {{-4} | 0  0   0  0  5t 0  0 0  |, {-4} | 0  0 0  0 -s 0 0  0 |, {-4} | |
|      {-3} | 0  0   5t 0  0  0  0 0  |  {-3} | 0  0 -s 0 0  0 0  0 |  {-3} | |
|      {-3} | 0  -5t 0  0  0  0  0 0  |  {-3} | 0  s 0  0 0  0 0  1 |  {-3} | |
|      {-3} | 5t 0   0  0  0  0  0 0  |  {-3} | -s 0 0  0 0  0 -1 0 |  {-3} | |
|      {-3} | 0  0   0  0  0  0  0 -1 |  {-3} | 0  0 0  0 0  0 0  0 |  {-3} | |
|      {-3} | 0  0   0  0  0  0  1 0  |  {-3} | 0  0 0  0 0  0 0  0 |  {-3} | |
|      {-3} | 0  0   0  0  0  -1 0 0  |  {-3} | 0  0 0  0 1  0 0  0 |  {-3} | |
|      {-2} | 0  0   0  -1 0  0  0 0  |  {-2} | 0  0 1  0 0  0 0  0 |  {-2} | |
|     ------------------------------------------------------------------------|
|     0     0    0      0     -12t 18t s+30t 0  |, {-4} | 0    0    0    0    |
|     0     0    -12t   18t   0    0   0     -1 |  {-3} | 0    0    12t  -10t |
|     0     12t  0      s+30t 0    0   0     0  |  {-3} | 0    -12t 0    -6t  |
|     -12t  0    0      0     0    1   0     0  |  {-3} | 12t  0    0    48t  |
|     0     -18t -s-30t 0     0    0   0     0  |  {-3} | 0    10t  6t   0    |
|     18t   0    0      0     -1   0   0     0  |  {-3} | -10t 0    -48t 0    |
|     s+30t 0    0      0     0    0   0     0  |  {-3} | -6t  48t  0    0    |
|     0     -1   0      0     0    0   0     0  |  {-2} | 1    0    0    0    |
|     ------------------------------------------------------------------------|
|     12t -10t -6t 48t |}                                                     |
|     0   0    1   0   |                                                      |
|     0   -1   0   0   |                                                      |
|     0   0    0   0   |                                                      |
|     1   0    0   0   |                                                      |
|     0   0    0   0   |                                                      |
|     0   0    0   0   |                                                      |
|     0   0    0   0   |                                                      |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * evenOperators -- part of a CliffordModule
  * evenCenter -- part of a CliffordModule
  * oddCenter -- part of a CliffordModule
  * symMatrix -- part of a CliffordModule
  * hyperellipticBranchEquation -- part of
    a CliffordModule

For the programmer
==================

The object oddOperators, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2164:0.

orderInPic -- order of a line bundle of degree 0 in Pic(E)
**********************************************************

  * Usage:
        N = orderInPic(L)
        N = orderInPic(phi)
  * Inputs:
      * L, an instance of the type VectorBundleOnE, a
        line bundle of degree 0 on E
      * phi, a matrix (Macaulay2Doc), a matrix which is the
        yAction of VectorBundleOnE
  * Outputs:
      * N, an integer (Macaulay2Doc), the order of L in Pic(E)

Description
===========

Computes the order of a degree 0 line bundle L on the hyperelliptic curve E by
the most naive method.

+-----------------------------------------------------------------------------+
|i1 : setRandomSeed 0                                                         |
| -- setting random seed to 0                                                 |
|                                                                             |
|o1 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i2 : kk=ZZ/101;                                                              |
+-----------------------------------------------------------------------------+
|i3 : g=1;                                                                    |
+-----------------------------------------------------------------------------+
|i4 : rNP=randNicePencil(kk,g);                                               |
+-----------------------------------------------------------------------------+
|i5 : f=(cliffordModule(rNP.matFact1,rNP.matFact2,rNP.baseRing)).             |
|                                                                             |
|          3       2 2        3      4                                        |
|o5 = - 12s t - 50s t  - 16s*t  + 47t                                         |
|                                                                             |
|o5 : kk[s, t]                                                                |
|-----------------------------------------------------------------------------|
|hyperellipticBranchEquation                                                  |
+-----------------------------------------------------------------------------+
|i6 : L=randomLineBundle(0,f);                                                |
+-----------------------------------------------------------------------------+
|i7 : orderInPic L                                                            |
|                                                                             |
|o7 = 37                                                                      |
+-----------------------------------------------------------------------------+

Caveat
======

The ground field kk has to be finite. It computes the order by checking
inductively whether L^k is trivial, so it may fail when kk is not finite, or
has too many elements. orderInPic(phi) may not terminate if it is not the
yAction of a line bundle of degree 0 on E.

See also
========

  * randomLineBundle -- a random balanced line bundle
    on the hyperelliptic curve
  * vectorBundleOnE -- creates a VectorBundleOnE,
    represented as a matrix factorization
  * VectorBundleOnE -- vector bundle on a hyperelliptic
    curve E
  * yAction -- defines a vector bundle on E

Ways to use orderInPic:
=======================

  * "orderInPic(Matrix)"
  * "orderInPic(VectorBundleOnE)"

For the programmer
==================

The object orderInPic, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:3032:0.

preRandomLineBundle -- a random line bundle on the hyperelliptic curve
**********************************************************************

  * Usage:
        L=preRandomLineBundle(f)
        Ld=preRandomLineBundle(d,f)
  * Inputs:
      * f, a ring element (Macaulay2Doc), the hyperelliptic
        branch equation of a CliffordModule.
      * d, an integer (Macaulay2Doc),
  * Outputs:
      * L, an instance of the type VectorBundleOnE, a
        line bundle on E
      * Ld, an instance of the type VectorBundleOnE, a
        line bundle on E of degree d.

Description
===========

Chooses a random line bundle on the hyperelliptic curve E of genus g given by
the equation y^2-(-1)^{g}*f, where f is the branch equation of degree (2g+2).
Input with an integer d gives a random line bundle of degree d on E.

Note that a line bundle on E is given by the y-action which is represented by a
traceless 2x2 matrix

b c

a -b

whose determinant equals to (-1)^{g}*f. We find such a matrix over a finite
ground field by picking randomly b, a homogeneous form of degree (g+1), since
the binary form b^2 + (-1)^{g}*f frequently factors.

+---------------------------------------------------------------+
|i1 : kk=ZZ/101;                                                |
+---------------------------------------------------------------+
|i2 : setRandomSeed 0                                           |
| -- setting random seed to 0                                   |
|                                                               |
|o2 = 0                                                         |
+---------------------------------------------------------------+
|i3 : g=1;                                                      |
+---------------------------------------------------------------+
|i4 : rNP=randNicePencil(kk,g);                                 |
+---------------------------------------------------------------+
|i5 : cM=cliffordModule(rNP.matFact1,rNP.matFact2,rNP.baseRing);|
+---------------------------------------------------------------+
|i6 : f=cM.hyperellipticBranchEquation                          |
|                                                               |
|          3       2 2        3      4                          |
|o6 = - 12s t - 50s t  - 16s*t  + 47t                           |
|                                                               |
|o6 : kk[s, t]                                                  |
+---------------------------------------------------------------+
|i7 : L=preRandomLineBundle(f)                                  |
|                                                               |
|o7 = VectorBundleOnE{...1...}                                  |
|                                                               |
|o7 : VectorBundleOnE                                           |
+---------------------------------------------------------------+
|i8 : degOnE L                                                  |
|                                                               |
|o8 = -1                                                        |
+---------------------------------------------------------------+
|i9 : m=L.yAction                                               |
|                                                               |
|o9 = {-2} | 39s2+21st+34t2 44s3-34s2t+7st2+2t3 |               |
|     {-1} | 32s+t          -39s2-21st-34t2     |               |
|                                                               |
|                      2               2                        |
|o9 : Matrix (kk[s, t])  <-- (kk[s, t])                         |
+---------------------------------------------------------------+
|i10 : (m)^2_(0,0)+(-1)^g*f==0                                  |
|                                                               |
|o10 = true                                                     |
+---------------------------------------------------------------+
|i11 : L0=preRandomLineBundle(0,f)                              |
|                                                               |
|o11 = VectorBundleOnE{...1...}                                 |
|                                                               |
|o11 : VectorBundleOnE                                          |
+---------------------------------------------------------------+
|i12 : degOnE L0                                                |
|                                                               |
|o12 = 0                                                        |
+---------------------------------------------------------------+
|i13 : orderInPic L0                                            |
|                                                               |
|o13 = 37                                                       |
+---------------------------------------------------------------+

Caveat
======

The ground field kk has to be finite.

See also
========

  * vectorBundleOnE -- creates a VectorBundleOnE,
    represented as a matrix factorization
  * VectorBundleOnE -- vector bundle on a hyperelliptic
    curve E
  * degOnE -- degree of a vector bundle on E
  * orderInPic -- order of a line bundle of degree 0 in
    Pic(E)
  * randomLineBundle -- a random balanced line bundle
    on the hyperelliptic curve

Ways to use preRandomLineBundle:
================================

  * "preRandomLineBundle(RingElement)"
  * "preRandomLineBundle(ZZ,RingElement)"

For the programmer
==================

The object preRandomLineBundle, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:3095:0.

qqRing -- part of a RandomNicePencil
************************************

  * Usage:
        S = rNP.qqRing
  * Outputs:
      * S, a ring (Macaulay2Doc), polynomial ring in g x's, g y's,
        z_1, z_2, and s, t.

Description
===========

The ambient polynomial ring where the quadratic form qq = s*q1 + t*q2 lives.

+------------------------------+
|i1 : setRandomSeed 0          |
| -- setting random seed to 0  |
|                              |
|o1 = 0                        |
+------------------------------+
|i2 : kk=ZZ/101;               |
+------------------------------+
|i3 : g=1;                     |
+------------------------------+
|i4 : rNP=randNicePencil(kk,g);|
+------------------------------+
|i5 : S=rNP.qqRing             |
|                              |
|o5 = S                        |
|                              |
|o5 : PolynomialRing           |
+------------------------------+

See also
========

  * baseRing of a RandomNicePencil, --
    part of a RandomNicePencil
  * quadraticForm -- part of a RandomNicePencil
  * matFact1 -- part of a RandomNicePencil
  * matFact2 -- part of a RandomNicePencil
  * matFactu1 -- part of a RandomNicePencil
  * matFactu2 -- part of a RandomNicePencil
  * isotropicSpace -- part of a RandomNicePencil

For the programmer
==================

The object qqRing, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2413:0.

quadraticForm -- part of a RandomNicePencil
*******************************************

  * Usage:
        qq = rNP.quadraticForm
  * Outputs:
      * qq, a ring element (Macaulay2Doc), an element of S,
        quadratic in x_0..z_2 and linear in s, t.

Description
===========

the polynomial that represents a pencil of quadrics qq=s*q1+t*q2 with a fixed
isotropic subspace and a fixed corank one quadric in normal form q1.

+-----------------------------------------------------------------------------+
|i1 : setRandomSeed 0                                                         |
| -- setting random seed to 0                                                 |
|                                                                             |
|o1 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i2 : kk=ZZ/101;                                                              |
+-----------------------------------------------------------------------------+
|i3 : g=1;                                                                    |
+-----------------------------------------------------------------------------+
|i4 : rNP=randNicePencil(kk,g);                                               |
+-----------------------------------------------------------------------------+
|i5 : S=rNP.qqRing;                                                           |
+-----------------------------------------------------------------------------+
|i6 : qq=rNP.quadraticForm                                                    |
|                                                                             |
|              2      2                           2                           |
|o6 = x y s - z s - 5x t + 12x z t - 18y z t - 30z t - 12x z t + 10y z t +    |
|      0 0     1      0       0 1       0 1       1       0 2       0 2       |
|     ------------------------------------------------------------------------|
|                 2                                                           |
|     6z z t - 48z t                                                          |
|       1 2       2                                                           |
|                                                                             |
|o6 : S                                                                       |
+-----------------------------------------------------------------------------+
|i7 : q1=diff(S_(2*g+2), qq)                                                  |
|                                                                             |
|             2                                                               |
|o7 = x y  - z                                                                |
|      0 0    1                                                               |
|                                                                             |
|o7 : S                                                                       |
+-----------------------------------------------------------------------------+
|i8 : q2=diff(S_(2*g+3), qq)                                                  |
|                                                                             |
|         2                        2                                2         |
|o8 = - 5x  + 12x z  - 18y z  - 30z  - 12x z  + 10y z  + 6z z  - 48z          |
|         0      0 1      0 1      1      0 2      0 2     1 2      2         |
|                                                                             |
|o8 : S                                                                       |
+-----------------------------------------------------------------------------+
|i9 : qq==S_(2*g+2)*q1+S_(2*g+3)*q2                                           |
|                                                                             |
|o9 = true                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * qqRing -- part of a RandomNicePencil
  * baseRing of a RandomNicePencil, --
    part of a RandomNicePencil
  * matFact1 -- part of a RandomNicePencil
  * matFact2 -- part of a RandomNicePencil
  * matFactu1 -- part of a RandomNicePencil
  * matFactu2 -- part of a RandomNicePencil
  * isotropicSpace -- part of a RandomNicePencil

For the programmer
==================

The object quadraticForm, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2448:0.

randNicePencil -- sets up a random pencil of quadrics, and returns a hash table of the type RandomNicePencil.
*************************************************************************************************************

  * Usage:
        L = randNicePencil(kk,g)
  * Inputs:
      * kk, a ring (Macaulay2Doc), the ground field, not char 2,
        please!
      * g, an integer (Macaulay2Doc), genus of the associated
        hyperelliptic curve.
  * Outputs:
      * L, an instance of the type RandomNicePencil,

Description
===========

Generates a random pencil of quadrics in the same way as
randomNicePencil(kk,g). Returns a hash table of the type RandomNicePencil.

+-----------------------------------------------------------------------------+
|i1 : setRandomSeed 0                                                         |
| -- setting random seed to 0                                                 |
|                                                                             |
|o1 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i2 : kk=ZZ/101;                                                              |
+-----------------------------------------------------------------------------+
|i3 : g=1;                                                                    |
+-----------------------------------------------------------------------------+
|i4 : L=randNicePencil(kk,g)                                                  |
|                                                                             |
|o4 = RandomNicePencil{...8...}                                               |
|                                                                             |
|o4 : RandomNicePencil                                                        |
+-----------------------------------------------------------------------------+
|i5 : keys L                                                                  |
|                                                                             |
|o5 = {matFact1, matFact2, matFactu1, isotropicSpace, matFactu2,              |
|     ------------------------------------------------------------------------|
|     quadraticForm, qqRing, baseRing}                                        |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : L.qqRing                                                                |
|                                                                             |
|o6 = kk[x , y , z ..z , s, t]                                                |
|         0   0   1   2                                                       |
|                                                                             |
|o6 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i7 : L.quadraticForm                                                         |
|                                                                             |
|              2      2                           2                           |
|o7 = x y s - z s - 5x t + 12x z t - 18y z t - 30z t - 12x z t + 10y z t +    |
|      0 0     1      0       0 1       0 1       1       0 2       0 2       |
|     ------------------------------------------------------------------------|
|                 2                                                           |
|     6z z t - 48z t                                                          |
|       1 2       2                                                           |
|                                                                             |
|o7 : kk[x , y , z ..z , s, t]                                                |
|         0   0   1   2                                                       |
+-----------------------------------------------------------------------------+
|i8 : L.baseRing                                                              |
|                                                                             |
|o8 = kk[s, t]                                                                |
|                                                                             |
|o8 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i9 : (L.matFact1 * L.matFact2) - (L.quadraticForm)**id_(source L.matFact1)   |
|                                                                             |
|o9 = 0                                                                       |
|                                                                             |
|                                      8                               8      |
|o9 : Matrix (kk[x , y , z ..z , s, t])  <-- (kk[x , y , z ..z , s, t])       |
|                 0   0   1   2                   0   0   1   2               |
+-----------------------------------------------------------------------------+
|i10 : (L.matFact2 * L.matFact1) - (L.quadraticForm)**id_(source L.matFact1)  |
|                                                                             |
|o10 = 0                                                                      |
|                                                                             |
|                                       8                               8     |
|o10 : Matrix (kk[x , y , z ..z , s, t])  <-- (kk[x , y , z ..z , s, t])      |
|                  0   0   1   2                   0   0   1   2              |
+-----------------------------------------------------------------------------+
|i11 : L.isotropicSpace                                                       |
|                                                                             |
|o11 = | x_0 z_1 z_2 |                                                        |
|                                                                             |
|                                       1                               3     |
|o11 : Matrix (kk[x , y , z ..z , s, t])  <-- (kk[x , y , z ..z , s, t])      |
|                  0   0   1   2                   0   0   1   2              |
+-----------------------------------------------------------------------------+
|i12 : (L.matFactu1 * L.matFactu2) -                                          |
|                                                                             |
|o12 = 0                                                                      |
|                                                                             |
|                                                                             |
|o12 : Matrix (kk[x , y , z ..z , s,                                          |
|                  0   0   1   2                                              |
|-----------------------------------------------------------------------------|
|(L.quadraticForm)**id_(source L.matFactu1)                                   |
|                                                                             |
|                                                                             |
|                                                                             |
|   4                               4                                         |
|t])  <-- (kk[x , y , z ..z , s, t])                                          |
|              0   0   1   2                                                  |
+-----------------------------------------------------------------------------+
|i13 : (L.matFactu2 * L.matFactu1) -                                          |
|                                                                             |
|o13 = 0                                                                      |
|                                                                             |
|                                                                             |
|o13 : Matrix (kk[x , y , z ..z , s,                                          |
|                  0   0   1   2                                              |
|-----------------------------------------------------------------------------|
|(L.quadraticForm)**id_(source L.matFactu1)                                   |
|                                                                             |
|                                                                             |
|                                                                             |
|   4                               4                                         |
|t])  <-- (kk[x , y , z ..z , s, t])                                          |
|              0   0   1   2                                                  |
+-----------------------------------------------------------------------------+

See also
========

  * randomNicePencil -- sets up a random example to
    construct Clifford algebra and representation
  * RandomNicePencil -- hash table holding details of
    a random pencil of quadrics

Ways to use randNicePencil:
===========================

  * "randNicePencil(Ring,ZZ)"

For the programmer
==================

The object randNicePencil, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2008:0.

randomExtension -- a random extension of a vector bundle on E by another vector bundle
**************************************************************************************

  * Usage:
        V=randomExtension(V1,V2)
        V=randomExtension(Y1,Y2)
  * Inputs:
      * V1, an instance of the type VectorBundleOnE,
      * V2, an instance of the type VectorBundleOnE,
      * Y1, a matrix (Macaulay2Doc), a matrix which is the
        yAction of some VectorBundleOnE
      * Y2, a matrix (Macaulay2Doc), a matrix which is the
        yAction of some VectorBundleOnE
  * Outputs:
      * V, an instance of the type VectorBundleOnE,

Description
===========

Chooses a random extension of V2 by V1, where V1, V2 are vector bundles on E
represented by the type VectorBundleOnE.

+-----------------------------------------------------------------------------+
|i1 : setRandomSeed 0                                                         |
| -- setting random seed to 0                                                 |
|                                                                             |
|o1 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i2 : kk=ZZ/101;                                                              |
+-----------------------------------------------------------------------------+
|i3 : g=1;                                                                    |
+-----------------------------------------------------------------------------+
|i4 : rNP=randNicePencil(kk,g);                                               |
+-----------------------------------------------------------------------------+
|i5 : cM=cliffordModule(rNP.matFact1,rNP.matFact2,rNP.baseRing);              |
+-----------------------------------------------------------------------------+
|i6 : f=cM.hyperellipticBranchEquation                                        |
|                                                                             |
|          3       2 2        3      4                                        |
|o6 = - 12s t - 50s t  - 16s*t  + 47t                                         |
|                                                                             |
|o6 : kk[s, t]                                                                |
+-----------------------------------------------------------------------------+
|i7 : L1=randomLineBundle(0,f)                                                |
|                                                                             |
|o7 = VectorBundleOnE{...1...}                                                |
|                                                                             |
|o7 : VectorBundleOnE                                                         |
+-----------------------------------------------------------------------------+
|i8 : L2=randomLineBundle(2,f)                                                |
|                                                                             |
|o8 = VectorBundleOnE{...1...}                                                |
|                                                                             |
|o8 : VectorBundleOnE                                                         |
+-----------------------------------------------------------------------------+
|i9 : V=randomExtension(L1,L2)                                                |
|                                                                             |
|o9 = VectorBundleOnE{...1...}                                                |
|                                                                             |
|o9 : VectorBundleOnE                                                         |
+-----------------------------------------------------------------------------+
|i10 : V.yAction                                                              |
|                                                                             |
|o10 = {-1} | -18s2-13st-43t2 13s2+45st-16t2 40s4+37s3t+16s2t2+35st3          |
|      {-1} | 45s2-14st-t2    18s2+13st+43t2 11s4+45s3t+6s2t2-5st3+3t4        |
|      {1}  | 0               0              48s2+36st+35t2                   |
|      {-1} | 0               0              44s4+s3t-22s2t2+33st3-t4         |
|      -----------------------------------------------------------------------|
|      -42s2-33st-48t2 |                                                      |
|      39s2-30st+32t2  |                                                      |
|      -34             |                                                      |
|      -48s2-36st-35t2 |                                                      |
|                                                                             |
|                       4               4                                     |
|o10 : Matrix (kk[s, t])  <-- (kk[s, t])                                      |
+-----------------------------------------------------------------------------+
|i11 : degOnE V                                                               |
|                                                                             |
|o11 = 2                                                                      |
+-----------------------------------------------------------------------------+
|i12 : V1=randomExtension(L2,V)                                               |
|                                                                             |
|o12 = VectorBundleOnE{...1...}                                               |
|                                                                             |
|o12 : VectorBundleOnE                                                        |
+-----------------------------------------------------------------------------+
|i13 : V1.yAction                                                             |
|                                                                             |
|o13 = {1}  | 48s2+36st+35t2           -34             36                     |
|      {-1} | 44s4+s3t-22s2t2+33st3-t4 -48s2-36st-35t2 29s2+40st-43t2         |
|      {-1} | 0                        0               -18s2-13st-43t2        |
|      {-1} | 0                        0               45s2-14st-t2           |
|      {1}  | 0                        0               0                      |
|      {-1} | 0                        0               0                      |
|      -----------------------------------------------------------------------|
|      -38            -22s2-40st+6t2               -29             |          |
|      41s2-19st-15t2 -28s4-20s3t+11s2t2+31st3-5t4 29s2-3st+50t2   |          |
|      13s2+45st-16t2 40s4+37s3t+16s2t2+35st3      -42s2-33st-48t2 |          |
|      18s2+13st+43t2 11s4+45s3t+6s2t2-5st3+3t4    39s2-30st+32t2  |          |
|      0              48s2+36st+35t2               -34             |          |
|      0              44s4+s3t-22s2t2+33st3-t4     -48s2-36st-35t2 |          |
|                                                                             |
|                       6               6                                     |
|o13 : Matrix (kk[s, t])  <-- (kk[s, t])                                      |
+-----------------------------------------------------------------------------+
|i14 : degOnE V1                                                              |
|                                                                             |
|o14 = 4                                                                      |
+-----------------------------------------------------------------------------+

See also
========

  * randomLineBundle -- a random balanced line bundle
    on the hyperelliptic curve
  * vectorBundleOnE -- creates a VectorBundleOnE,
    represented as a matrix factorization
  * VectorBundleOnE -- vector bundle on a hyperelliptic
    curve E
  * degOnE -- degree of a vector bundle on E

Ways to use randomExtension:
============================

  * "randomExtension(Matrix,Matrix)"
  * "randomExtension(VectorBundleOnE,VectorBundleOnE)"

For the programmer
==================

The object randomExtension, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:3195:0.

randomIsotropicSubspace -- choose a random isotropic subspace
*************************************************************

  * Usage:
        ru=randomIsotropicSubspace(M,S)
  * Inputs:
      * M, an instance of the type CliffordModule,
        corresponding to a maximal isotropic subspace u
      * S, a ring (Macaulay2Doc), a polynomial ring
        kk[x_0..y_{(g-1)},z_0,z_1,s,t] in (2g+4) variables
  * Outputs:
      * ru, a matrix (Macaulay2Doc), a matrix presenting a random
        maximal isotropic subspace

Description
===========

Reid's theorem says that the set of maximal isotropic subspaces on a complete
intersection of two quadrics in (2g+2) variables is isomorphic to the set of
degree 0 line bundles on the associated hyperelliptic curve E of genus g. The
method chooses a random line bundle L of degree 0 on E, and computes the
maximal isotropic subspace ru corresponding to the translation of u by L.

+------------------------------------------------------------------+
|i1 : kk=ZZ/101;                                                   |
+------------------------------------------------------------------+
|i2 : setRandomSeed 0                                              |
| -- setting random seed to 0                                      |
|                                                                  |
|o2 = 0                                                            |
+------------------------------------------------------------------+
|i3 : g=2;                                                         |
+------------------------------------------------------------------+
|i4 : (S,qq,R,u, M1,M2, Mu1,Mu2) = randomNicePencil(kk,g);         |
+------------------------------------------------------------------+
|i5 : M=cliffordModule (Mu1, Mu2, R);                              |
+------------------------------------------------------------------+
|i6 : ru=randomIsotropicSubspace(M,S)                              |
|                                                                  |
|o6 = | y_1+28z_1+48z_2 y_0+16z_1-21z_2 x_1-18z_1+25z_2 x_0-15z_2 ||
|                                                                  |
|             1      4                                             |
|o6 : Matrix S  <-- S                                              |
+------------------------------------------------------------------+
|i7 : assert (betti ru == betti u)                                 |
+------------------------------------------------------------------+

Caveat
======

The ground field kk (=coefficientRing S) has to be finite, since it uses the
method randomLineBundle.

See also
========

  * translateIsotropicSubspace -- choose a
    random isotropic subspace
  * randomLineBundle -- a random balanced line bundle
    on the hyperelliptic curve
  * CliffordModule -- hash table holding details of a
    Clifford module

Ways to use randomIsotropicSubspace:
====================================

  * "randomIsotropicSubspace(CliffordModule,PolynomialRing)"

For the programmer
==================

The object randomIsotropicSubspace, is a
method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:3545:0.

randomLineBundle -- a random balanced line bundle on the hyperelliptic curve
****************************************************************************

  * Usage:
        L=randomLineBundle(f)
        Ld=randomLineBundle(d,f)
  * Inputs:
      * f, a ring element (Macaulay2Doc), the hyperelliptic
        branch equation of a CliffordModule.
      * d, an integer (Macaulay2Doc),
  * Outputs:
      * L, an instance of the type VectorBundleOnE, a
        line bundle on E
      * Ld, an instance of the type VectorBundleOnE, a
        line bundle on E of degree d.

Description
===========

Chooses a random line bundle on the hyperelliptic curve E of genus g given by
the equation y^2-(-1)^{g}*f, where f is the branch equation of degree (2g+2).
Input with an integer d gives a random line bundle of degree d on E.

Note that the method preRandomLineBundle mostly constructs an unbalanced line
bundle, that is, the degrees of a and c for the determinantal representation of
(-1)^{g}*f have a big gap. Such a line bundle will be contained in the theta
divisor (after a certain twist), so we make it into a balanced line bundle by
tensoring degree 0 line bundles.

+------------------------------------------------------------------------+
|i1 : kk=ZZ/1009;                                                        |
+------------------------------------------------------------------------+
|i2 : g=2;                                                               |
+------------------------------------------------------------------------+
|i3 : rNP=randNicePencil(kk,g);                                          |
+------------------------------------------------------------------------+
|i4 : cM=cliffordModule(rNP.matFact1,rNP.matFact2,rNP.baseRing);         |
+------------------------------------------------------------------------+
|i5 : f=cM.hyperellipticBranchEquation                                   |
|                                                                        |
|          5        4 2       3 3      2 4         5       6             |
|o5 = - 69s t + 250s t  + 256s t  - 22s t  - 299s*t  + 111t              |
|                                                                        |
|o5 : kk[s, t]                                                           |
+------------------------------------------------------------------------+
|i6 : tally apply(30, i->(Lp=preRandomLineBundle(1,f); betti Lp.yAction))|
|                                                                        |
|                  0 1                                                   |
|o6 = Tally{total: 2 2 => 2 }                                            |
|              -1: 2 .                                                   |
|               0: . .                                                   |
|               1: . 2                                                   |
|                  0 1                                                   |
|           total: 2 2 => 28                                             |
|              -2: 1 .                                                   |
|              -1: . .                                                   |
|               0: 1 1                                                   |
|               1: . .                                                   |
|               2: . 1                                                   |
|                                                                        |
|o6 : Tally                                                              |
+------------------------------------------------------------------------+
|i7 : tally apply(30, i->(L=randomLineBundle(1,f); betti L.yAction))     |
|                                                                        |
|                  0 1                                                   |
|o7 = Tally{total: 2 2 => 30}                                            |
|              -1: 2 .                                                   |
|               0: . .                                                   |
|               1: . 2                                                   |
|                                                                        |
|o7 : Tally                                                              |
+------------------------------------------------------------------------+

Caveat
======

The ground field kk has to be finite.

See also
========

  * preRandomLineBundle -- a random line bundle on
    the hyperelliptic curve
  * vectorBundleOnE -- creates a VectorBundleOnE,
    represented as a matrix factorization
  * VectorBundleOnE -- vector bundle on a hyperelliptic
    curve E
  * degOnE -- degree of a vector bundle on E
  * orderInPic -- order of a line bundle of degree 0 in
    Pic(E)

Ways to use randomLineBundle:
=============================

  * "randomLineBundle(RingElement)"
  * "randomLineBundle(ZZ,RingElement)"

For the programmer
==================

The object randomLineBundle, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:3148:0.

RandomNicePencil -- hash table holding details of a random pencil of quadrics
*****************************************************************************

Description
===========

the keys are qqRing => S, quadraticForm => a pencil of quadrics qq=s*q1+t*q2,
baseRing => R = kk[s,t], isotropicSpace => u, matFact1 => M1, matFact2 => M2,
matFactu1 => Mu1, matFactu2 => Mu2,

See also
========

  * randomNicePencil -- sets up a random example to
    construct Clifford algebra and representation
  * randNicePencil -- sets up a random pencil of
    quadrics, and returns a hash table of the type RandomNicePencil.

For the programmer
==================

The object RandomNicePencil, is a type (Macaulay2Doc),
with ancestor classes MutableHashTable (Macaulay2Doc),
< HashTable (Macaulay2Doc) <
Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2106:0.

randomNicePencil -- sets up a random example to construct Clifford algebra and representation
*********************************************************************************************

  * Usage:
        (S, qq, R,  u, M1, M2, Mu1, Mu2)=randomNicePencil(kk,g)
  * Inputs:
      * kk, a ring (Macaulay2Doc), the ground field, not char 2,
        please!
      * g, an integer (Macaulay2Doc), genus of the associated
        hyperelliptic curve.
  * Outputs:
      * S, a ring (Macaulay2Doc), polynomial ring in g x's, g y's
        z_1,z_2 and s, t
      * qq, a ring element (Macaulay2Doc), Element of S,
        quadratic in x_0..z_2 and linear in s,t
      * R, a ring (Macaulay2Doc), polynomial ring kk[s,t]
      * u, a matrix (Macaulay2Doc), 1 x g+2 row matrix with
        entries x_0..x_{(g-1)}, z_1,z_2; generators of the ideal of an
        isotropic subspace for qq
      * M1, a matrix (Macaulay2Doc),
      * M2, a matrix (Macaulay2Doc), Matrices over S such that
        M1*M2 = qq times an identity of size 2^{2g+1}
      * Mu1, a matrix (Macaulay2Doc),
      * Mu2, a matrix (Macaulay2Doc), Matrices over S such that
        Mu1*Mu2 = qq times an identity of size 2^{g+1}

Description
===========

Chooses a random example of a pencil of quadrics qq = s*q1+t*q2 with a fixed
isotropic subspace (defined by ideal u) and a fixed corank one quadric in
normal form q1.

When called with no arguments it prints a usage message.

The variables of S that are entries of X:= matrix
\{\{x_0..y_{(g-1)},z_1,z_2\}\} \, represent coordinates on PP_R^{2g+1}.

M1, M2 are consecutive high syzygy matrices in the minimal (periodic)
resolution of kk[s,t] = S/(ideal X) as a module over S/qq. These are used to
construct the Clifford algebra of qq.

Mu1, Mu2 are consecutive high syzygy matrices in the minimal (periodic)
resolution of S/(ideal u) as a module over S/qq. These are used to construct a
Morita bundle between the even Clifford algebra of qq and the hyperelliptic
curve branched over the degeneracy locus of the pencil,

\{(s,t) | s*q1+t*q2 is singular\} \subset PP^1.

+-------------------------------------------------------------+
|i1 : setRandomSeed 0                                         |
| -- setting random seed to 0                                 |
|                                                             |
|o1 = 0                                                       |
+-------------------------------------------------------------+
|i2 : kk=ZZ/101                                               |
|                                                             |
|o2 = kk                                                      |
|                                                             |
|o2 : QuotientRing                                            |
+-------------------------------------------------------------+
|i3 : g=1                                                     |
|                                                             |
|o3 = 1                                                       |
+-------------------------------------------------------------+
|i4 : (S, qq, R,  u, M1, M2, Mu1, Mu2)=randomNicePencil(kk,g);|
+-------------------------------------------------------------+
|i5 : gens S                                                  |
|                                                             |
|o5 = {x , y , z , z , s, t}                                  |
|       0   0   1   2                                         |
|                                                             |
|o5 : List                                                    |
+-------------------------------------------------------------+
|i6 : q1 = diff(S_(2*g+2),qq)                                 |
|                                                             |
|             2                                               |
|o6 = x y  - z                                                |
|      0 0    1                                               |
|                                                             |
|o6 : S                                                       |
+-------------------------------------------------------------+

a quadratic form of corank 1 (corresponding to a branch point of E-->PP^1 in
normal form.

+------------------------------------------------+
|i7 : ideal u -- an isotropic space for q1 and q2|
|                                                |
|o7 = ideal (x , z , z )                         |
|             0   1   2                          |
|                                                |
|o7 : Ideal of S                                 |
+------------------------------------------------+
|i8 : betti Mu1, betti Mu2                       |
|                                                |
|             0 1         0 1                    |
|o8 = (total: 4 4, total: 4 4)                   |
|          1: 3 1      2: 1 .                    |
|          2: 1 3      3: 3 3                    |
|                      4: . 1                    |
|                                                |
|o8 : Sequence                                   |
+------------------------------------------------+
|i9 : Mu1*Mu2- qq*id_(target Mu1) == 0           |
|                                                |
|o9 = true                                       |
+------------------------------------------------+

See also
========

  * CliffordModule -- hash table holding details of a
    Clifford module
  * cliffordModule -- makes a clifford Module
  * cliffordOperators -- Generators for a Clifford
    Algebra
  * centers -- even and odd action of the center of the even
    Clifford algebra

Ways to use randomNicePencil:
=============================

  * "randomNicePencil(Ring,ZZ)"

For the programmer
==================

The object randomNicePencil, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:1970:0.

searchUlrich -- searching an Ulrich module of smallest possible rank, or an Ulrich module of given rank.
********************************************************************************************************

  * Usage:
        Ulr = searchUlrich(M,S)
        Ulr = searchUlrich(M,S,r)
  * Inputs:
      * M, an instance of the type CliffordModule,
      * S, a ring (Macaulay2Doc), a polynomial ring in
        x_0..y_(g-1),z_1,z_2,s,t
      * r, an integer (Macaulay2Doc), an integer greater than 1,
        either g or r is even
  * Outputs:
      * Ulr, a module (Macaulay2Doc), a module on S supported on
        x_0..y_(g-1),z_1,z_2

Description
===========

M is assumed to be a Clifford module with a Morita bundle F_u, i.e., associated
to a maximal isotropic subspace u.

Let G be a coherent sheaf on a hyperelliptic curve E, and N be the
corresponding module over CI=P/ideal(q1,q2). Using the Tate resolution of u in
a complete intersection of 2 quadrics, one can compute the graded Betti numbers
of N by the rank of cohomology groups of G twisted by the Morita bundle F_u. In
particular, an Ulrich module on CI corresponds to a sheaf G on E such that G
\otimes F_u is an Ulrich bundle on E.

From this perspective, Eisenbud and Schreyer conjectured that it is the case
when G is a general vector bundle of rank \ge 2 of suitable degree.

searchUlrich looks for a candidate G of rank 2 on E and returns a module on S
supported on a CI V(q_1,q_2) \subset PP^{2g+1}.

When r is indicated, searchUlrich looks for a candidate G of rank r on E and
returns a module on S supported on a CI V(q_1,q_2) \subset PP^{2g+1}.

+-----------------------------------------------------------------------------+
|i1 : kk=ZZ/101;                                                              |
+-----------------------------------------------------------------------------+
|i2 : setRandomSeed 0                                                         |
| -- setting random seed to 0                                                 |
|                                                                             |
|o2 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i3 : g=2;                                                                    |
+-----------------------------------------------------------------------------+
|i4 : rNP=randNicePencil(kk,g);                                               |
+-----------------------------------------------------------------------------+
|i5 : S=rNP.qqRing;                                                           |
+-----------------------------------------------------------------------------+
|i6 : R=rNP.baseRing;                                                         |
+-----------------------------------------------------------------------------+
|i7 : qq=rNP.quadraticForm;                                                   |
+-----------------------------------------------------------------------------+
|i8 : qs=apply(2,i->diff(S_(2*g+2+i),qq))                                     |
|                                                                             |
|                     2     2               2                                 |
|o8 = {x y  + x y  - z , 35x  + 39x x  - 40x  - 13x y  + 44x y  + 39x y  -    |
|       0 0    1 1    1     0      0 1      1      0 0      1 0      0 1      |
|     ------------------------------------------------------------------------|
|                                                     2                       |
|     37x y  - 30x z  + 42x z  + 29y z  + 48y z  - 44z  + x z  - 43x z  -     |
|        1 1      0 1      1 1      0 1      1 1      1    0 2      1 2       |
|     ------------------------------------------------------------------------|
|                                  2                                          |
|     6y z  + 23y z  + 31z z  - 38z }                                         |
|       0 2      1 2      1 2      2                                          |
|                                                                             |
|o8 : List                                                                    |
+-----------------------------------------------------------------------------+
|i9 : Mu1=rNP.matFactu1;                                                      |
|                                                                             |
|             8      8                                                        |
|o9 : Matrix S  <-- S                                                         |
+-----------------------------------------------------------------------------+
|i10 : Mu2=rNP.matFactu2;                                                     |
|                                                                             |
|              8      8                                                       |
|o10 : Matrix S  <-- S                                                        |
+-----------------------------------------------------------------------------+
|i11 : M=cliffordModule(Mu1,Mu2,R)                                            |
|                                                                             |
|o11 = CliffordModule{...6...}                                                |
|                                                                             |
|o11 : CliffordModule                                                         |
+-----------------------------------------------------------------------------+
|i12 : elapsedTime Ulr = searchUlrich(M,S);                                   |
| -- .989721s elapsed                                                         |
+-----------------------------------------------------------------------------+
|i13 : betti freeResolution Ulr                                               |
|                                                                             |
|             0  1 2                                                          |
|o13 = total: 8 16 8                                                          |
|          0: 8 16 8                                                          |
|                                                                             |
|o13 : BettiTally                                                             |
+-----------------------------------------------------------------------------+
|i14 : ann Ulr == ideal qs                                                    |
|                                                                             |
|o14 = true                                                                   |
+-----------------------------------------------------------------------------+
|i15 : elapsedTime Ulr3 = searchUlrich(M,S,3);                                |
| -- 4.8437s elapsed                                                          |
+-----------------------------------------------------------------------------+
|i16 : betti freeResolution Ulr3                                              |
|                                                                             |
|              0  1  2                                                        |
|o16 = total: 12 24 12                                                        |
|          0: 12 24 12                                                        |
|                                                                             |
|o16 : BettiTally                                                             |
+-----------------------------------------------------------------------------+
|i17 : ann Ulr3 == ideal qs                                                   |
|                                                                             |
|o17 = true                                                                   |
+-----------------------------------------------------------------------------+

Caveat
======

searchUlrich uses the method randomLineBundle, so the ground field kk has to be
finite.

See also
========

  * cliffordModule -- makes a clifford Module
  * LabBookProtocol -- Print commands that lead to a
    construction of a Ulrich bundle

Ways to use searchUlrich:
=========================

  * "searchUlrich(CliffordModule,Ring)"
  * "searchUlrich(CliffordModule,Ring,ZZ)"

For the programmer
==================

The object searchUlrich, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:3389:0.

symMatrix -- part of a CliffordModule
*************************************

  * Usage:
        s = symMatrix(eOdd,eEv)
  * Inputs:
      * eOdd, a list (Macaulay2Doc),
      * eEv, a list (Macaulay2Doc), operators on a Clifford Module
  * Outputs:
      * s, a matrix (Macaulay2Doc), over k[s,t], the base of the
        Clifford algebra

Description
===========

Computes the matrix given by the pencil of quadrics defining the Clifford
algebra.

+-----------------------------------------------------------------------------+
|i1 : kk = ZZ/101                                                             |
|                                                                             |
|o1 = kk                                                                      |
|                                                                             |
|o1 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i2 : setRandomSeed 0                                                         |
| -- setting random seed to 0                                                 |
|                                                                             |
|o2 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i3 : g = 1                                                                   |
|                                                                             |
|o3 = 1                                                                       |
+-----------------------------------------------------------------------------+
|i4 : (S, qq,  R,  u, M1, M2, Mu1, Mu2)=randomNicePencil(kk,g);               |
+-----------------------------------------------------------------------------+
|i5 : M = cliffordModule(M1,M2, R)                                            |
|                                                                             |
|o5 = CliffordModule{...6...}                                                 |
|                                                                             |
|o5 : CliffordModule                                                          |
+-----------------------------------------------------------------------------+
|i6 : M.evenOperators                                                         |
|                                                                             |
|o6 = {{-1} | 0  0  0 -1 0  0   0  0  |, {-1} | 0  0  0 0 0  -1 0  0  |, {-1} |
|      {-1} | 0  0  1 0  0  0   0  0  |  {-1} | 0  0  0 0 1  0  0  0  |  {-1} |
|      {-1} | 0  -1 0 0  0  0   0  0  |  {-1} | 0  0  0 0 0  0  0  0  |  {-1} |
|      {-1} | 0  0  0 0  0  0   0  5t |  {-1} | 0  -1 0 0 0  0  0  -s |  {-1} |
|      {-2} | -1 0  0 0  0  0   0  0  |  {-2} | 0  0  0 0 0  0  0  0  |  {-2} |
|      {-2} | 0  0  0 0  0  0   5t 0  |  {-2} | -1 0  0 0 0  0  -s 0  |  {-2} |
|      {-2} | 0  0  0 0  0  -5t 0  0  |  {-2} | 0  0  0 0 0  s  0  0  |  {-2} |
|      {-2} | 0  0  0 0  5t 0   0  0  |  {-2} | 0  0  0 0 -s 0  0  0  |  {-2} |
|     ------------------------------------------------------------------------|
|     | 0  0     0    0      0    0     -1   0     |, {-1} | 0  0    0   0    |
|     | 0  0     0    0      0    0     0    s+30t |  {-1} | 0  0    0   0    |
|     | 0  0     0    0      1    0     0    -18t  |  {-1} | 0  0    0   0    |
|     | 0  0     -1   0      0    0     0    -12t  |  {-1} | 0  0    0   -1   |
|     | 0  0     0    0      0    s+30t -18t 0     |  {-2} | 0  0    0   0    |
|     | 0  0     0    -s-30t 0    0     -12t 0     |  {-2} | 0  0    48t 6t   |
|     | -1 0     0    18t    0    12t   0    0     |  {-2} | 0  -48t 0   -10t |
|     | 0  s+30t -18t 0      -12t 0     0    0     |  {-2} | -1 -6t  10t 0    |
|     ------------------------------------------------------------------------|
|     0    0    0   -48t |}                                                   |
|     0    0    -1  -6t  |                                                    |
|     0    1    0   10t  |                                                    |
|     0    0    0   12t  |                                                    |
|     -48t -6t  10t 0    |                                                    |
|     0    0    12t 0    |                                                    |
|     0    -12t 0   0    |                                                    |
|     12t  0    0   0    |                                                    |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+
|i7 : symMatrix(M.evenOperators,M.oddOperators)                               |
|                                                                             |
|o7 = | -5t  -50s 6t     -6t  |                                               |
|     | -50s 0    -9t    5t   |                                               |
|     | 6t   -9t  -s-30t 3t   |                                               |
|     | -6t  5t   3t     -48t |                                               |
|                                                                             |
|             4      4                                                        |
|o7 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+

See also
========

  * evenOperators -- part of a CliffordModule
  * oddOperators -- part of a CliffordModule
  * oddCenter -- part of a CliffordModule
  * oddCenter -- part of a CliffordModule
  * hyperellipticBranchEquation -- part of
    a CliffordModule

For the programmer
==================

The object symMatrix, is a function closure (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2286:0.

symmetricM -- part of a CliffordModule
**************************************

  * Usage:
        Q = M.symmetricM
  * Outputs:
      * Q, a matrix (Macaulay2Doc), over k[s,t]

Description
===========

the underlying pencil of quadratic forms

+--------------------------------------------------------------+
|i1 : setRandomSeed 0                                          |
| -- setting random seed to 0                                  |
|                                                              |
|o1 = 0                                                        |
+--------------------------------------------------------------+
|i2 : kk = ZZ/101                                              |
|                                                              |
|o2 = kk                                                       |
|                                                              |
|o2 : QuotientRing                                             |
+--------------------------------------------------------------+
|i3 : g = 1                                                    |
|                                                              |
|o3 = 1                                                        |
+--------------------------------------------------------------+
|i4 : (S, qq,  R,  u, M1, M2, Mu1, Mu2)=randomNicePencil(kk,g);|
+--------------------------------------------------------------+
|i5 : M = cliffordModule(M1,M2, R)                             |
|                                                              |
|o5 = CliffordModule{...6...}                                  |
|                                                              |
|o5 : CliffordModule                                           |
+--------------------------------------------------------------+
|i6 : M.symmetricM                                             |
|                                                              |
|o6 = | -5t  -50s 6t     -6t  |                                |
|     | -50s 0    -9t    5t   |                                |
|     | 6t   -9t  -s-30t 3t   |                                |
|     | -6t  5t   3t     -48t |                                |
|                                                              |
|             4      4                                         |
|o6 : Matrix R  <-- R                                          |
+--------------------------------------------------------------+

this can also be obtained by

+----------------------------------------------+
|i7 : symMatrix(M.evenOperators,M.oddOperators)|
|                                              |
|o7 = | -5t  -50s 6t     -6t  |                |
|     | -50s 0    -9t    5t   |                |
|     | 6t   -9t  -s-30t 3t   |                |
|     | -6t  5t   3t     -48t |                |
|                                              |
|             4      4                         |
|o7 : Matrix R  <-- R                          |
+----------------------------------------------+

See also
========

  * evenOperators -- part of a CliffordModule
  * oddOperators -- part of a CliffordModule
  * oddCenter -- part of a CliffordModule
  * oddCenter -- part of a CliffordModule
  * symMatrix -- part of a CliffordModule
  * hyperellipticBranchEquation -- part of
    a CliffordModule

For the programmer
==================

The object symmetricM, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2223:0.

tensorProduct -- tensor product of sheaves on the elliptic curve or sheaf times CliffordModule
**********************************************************************************************

  * Usage:
        eta = tensorProduct(phi,psi)
        G = tensorProduct(M,V)
        L = tensorProduct(L1,L2)
  * Inputs:
      * phi, a matrix (Macaulay2Doc),
      * psi, a matrix (Macaulay2Doc), representing the action of
        y on a sheaf on PP^1
      * L1, an instance of the type VectorBundleOnE,
      * L2, an instance of the type VectorBundleOnE,
      * M, an instance of the type CliffordModule,
      * V, an instance of the type VectorBundleOnE,
  * Outputs:
      * eta, a matrix (Macaulay2Doc), action of y
      * N, an instance of the type CliffordModule,
      * L, an instance of the type VectorBundleOnE,

Description
===========

Sheaves on the hyperelliptic curve y^2 -(-1)^{g}* f(s,t) are represented as
sheaves on PP^1 together with the action of y. Clifford modules are represented
as the action of maps eOdd_i: M_1 \to M_0 and eEv_i:M_0 \to M_1 between the
even and odd parts of the module. The result are the corresponding data for the
tensor product.

+------------------------------------------------------------------------+
|i1 : kk=ZZ/101                                                          |
|                                                                        |
|o1 = kk                                                                 |
|                                                                        |
|o1 : QuotientRing                                                       |
+------------------------------------------------------------------------+
|i2 : setRandomSeed 0                                                    |
| -- setting random seed to 0                                            |
|                                                                        |
|o2 = 0                                                                  |
+------------------------------------------------------------------------+
|i3 : g=1                                                                |
|                                                                        |
|o3 = 1                                                                  |
+------------------------------------------------------------------------+
|i4 : (S, qq,  R,  u, M1, M2, Mu1, Mu2)=randomNicePencil(kk,g) ;         |
+------------------------------------------------------------------------+
|i5 : (uOdd,uEv)=cliffordOperators(Mu1,Mu2,R);                           |
+------------------------------------------------------------------------+
|i6 : symMatrix(uOdd,uEv)                                                |
|                                                                        |
|o6 = | -5t  -50s 6t     -6t  |                                          |
|     | -50s 0    -9t    5t   |                                          |
|     | 6t   -9t  -s-30t 3t   |                                          |
|     | -6t  5t   3t     -48t |                                          |
|                                                                        |
|             4      4                                                   |
|o6 : Matrix R  <-- R                                                    |
+------------------------------------------------------------------------+
|i7 : f=det symMatrix(uOdd,uEv);                                         |
+------------------------------------------------------------------------+
|i8 : M = cliffordModule(uOdd, uEv);                                     |
+------------------------------------------------------------------------+
|i9 : L = randomLineBundle(0,f);                                         |
+------------------------------------------------------------------------+
|i10 : L.yAction                                                         |
|                                                                        |
|o10 = {-1} | -18s2-13st-43t2 13s2+45st-16t2 |                           |
|      {-1} | 45s2-14st-t2    18s2+13st+43t2 |                           |
|                                                                        |
|              2      2                                                  |
|o10 : Matrix R  <-- R                                                   |
+------------------------------------------------------------------------+
|i11 : L2 = tensorProduct(L,L)                                           |
|                                                                        |
|o11 = VectorBundleOnE{...1...}                                          |
|                                                                        |
|o11 : VectorBundleOnE                                                   |
+------------------------------------------------------------------------+
|i12 : L2.yAction                                                        |
|                                                                        |
|o12 = {-1} | -18s2+6st+19t2 13s2-3st-16t2 |                             |
|      {-1} | 45s2-5st+7t2   18s2-6st-19t2 |                             |
|                                                                        |
|              2      2                                                  |
|o12 : Matrix R  <-- R                                                   |
+------------------------------------------------------------------------+
|i13 : M' = tensorProduct(M,L)                                           |
|                                                                        |
|o13 = CliffordModule{...6...}                                           |
|                                                                        |
|o13 : CliffordModule                                                    |
+------------------------------------------------------------------------+
|i14 : M.evenCenter                                                      |
|                                                                        |
|o14 = {-4} | -49st-24t2 -24s2t+47st2-42t3 -10t3     -25st2-43t3   |     |
|      {-3} | -50s       49st+24t2         -25t2     -45t2         |     |
|      {-3} | -9t        5st+49t2          49st-17t2 50s2-15st+7t2 |     |
|      {-3} | 5t         -2t2              24st+41t2 -49st+17t2    |     |
|                                                                        |
|              4      4                                                  |
|o14 : Matrix R  <-- R                                                   |
+------------------------------------------------------------------------+
|i15 : M'.evenCenter                                                     |
|                                                                        |
|o15 = {-4} | 47st+18t2 45s2t-33st2-27t3 24st2-11t3     -6st2+11t3      ||
|      {-3} | -7s+37t   -30st+7t2        34st+5t2       14st-5t2        ||
|      {-3} | 35s-34t   -3s2-5st-7t2     -6s2+19st-t2   -50s2-49st+43t2 ||
|      {-3} | -26s+50t  -36s2-37st+36t2  29s2+44st-35t2 6s2-36st-24t2   ||
|                                                                        |
|              4      4                                                  |
|o15 : Matrix R  <-- R                                                   |
+------------------------------------------------------------------------+

See also
========

  * CliffordModule -- hash table holding details of a
    Clifford module
  * cliffordOperators -- Generators for a Clifford
    Algebra
  * symMatrix -- part of a CliffordModule
  * randomLineBundle -- a random balanced line bundle
    on the hyperelliptic curve
  * evenCenter -- part of a CliffordModule

Ways to use tensorProduct:
==========================

  * "tensorProduct(CliffordModule,VectorBundleOnE)"
  * "tensorProduct(Matrix,Matrix)"
  * "tensorProduct(VectorBundleOnE,VectorBundleOnE)"

For the programmer
==================

The object tensorProduct, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2947:0.

translateIsotropicSubspace -- choose a random isotropic subspace
****************************************************************

  * Usage:
        uL=translateIsotropicSubspace(M,L,S)
  * Inputs:
      * M, an instance of the type CliffordModule,
        corresponding to a maximal isotropic subspace u
      * L, an instance of the type VectorBundleOnE, a
        degree 0 line bundle on the associated hyperelliptic curve E of genus
        g.
      * S, a polynomial ring (Macaulay2Doc), a polynomial
        ring kk[x_0..y_{(g-1)},z_0,z_1,s,t] in (2g+4) variables
  * Outputs:
      * uL, a matrix (Macaulay2Doc), a matrix presenting a
        maximal isotropic subspace u translated by L

Description
===========

Reid's theorem says that the set of maximal isotropic subspaces on a complete
intersection of two quadrics in (2g+2) variables is isomorphic to the set of
degree 0 line bundles on the associated hyperelliptic curve E of genus g. The
method computes the maximal isotropic subspace uL corresponding to the
translation of u by L.

+------------------------------------------------------------------+
|i1 : kk=ZZ/101;                                                   |
+------------------------------------------------------------------+
|i2 : setRandomSeed 0                                              |
| -- setting random seed to 0                                      |
|                                                                  |
|o2 = 0                                                            |
+------------------------------------------------------------------+
|i3 : g=2;                                                         |
+------------------------------------------------------------------+
|i4 : (S,qq,R,u, M1,M2, Mu1,Mu2) = randomNicePencil(kk,g);         |
+------------------------------------------------------------------+
|i5 : M=cliffordModule (Mu1, Mu2, R);                              |
+------------------------------------------------------------------+
|i6 : f=M.hyperellipticBranchEquation                              |
|                                                                  |
|        5      4 2      3 3      2 4        5      6              |
|o6 = 15s t + 6s t  + 33s t  + 30s t  - 48s*t  + 14t               |
|                                                                  |
|o6 : R                                                            |
+------------------------------------------------------------------+
|i7 : L=randomLineBundle(0,f);                                     |
+------------------------------------------------------------------+
|i8 : uL=translateIsotropicSubspace(M,L,S)                         |
|                                                                  |
|o8 = | y_1+28z_1+48z_2 y_0+16z_1-21z_2 x_1-18z_1+25z_2 x_0-15z_2 ||
|                                                                  |
|             1      4                                             |
|o8 : Matrix S  <-- S                                              |
+------------------------------------------------------------------+
|i9 : assert (betti uL == betti u)                                 |
+------------------------------------------------------------------+

See also
========

  * randomIsotropicSubspace -- choose a random
    isotropic subspace
  * randomLineBundle -- a random balanced line bundle
    on the hyperelliptic curve
  * CliffordModule -- hash table holding details of a
    Clifford module

Ways to use translateIsotropicSubspace:
=======================================

  * "translateIsotropicSubspace(CliffordModule,VectorBundleOnE,PolynomialRing)"

For the programmer
==================

The object translateIsotropicSubspace, is a
method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:3502:0.

VectorBundleOnE -- vector bundle on a hyperelliptic curve E
***********************************************************

Description
===========

If the curve has equation y^2 +/- f, then the bundle is represented by a vector
bundle on PP^1 and a matrix representing the action of y. the only  key is
yAction

See also
========

  * vectorBundleOnE -- creates a VectorBundleOnE,
    represented as a matrix factorization
  * degOnE -- degree of a vector bundle on E
  * orderInPic -- order of a line bundle of degree 0 in
    Pic(E)
  * randomLineBundle -- a random balanced line bundle
    on the hyperelliptic curve
  * randomExtension -- a random extension of a vector
    bundle on E by another vector bundle
  * yAction -- defines a vector bundle on E

Methods that use an object of class VectorBundleOnE:
====================================================

  * "degOnE(VectorBundleOnE)" -- see degOnE, -- degree of a
    vector bundle on E
  * "orderInPic(VectorBundleOnE)" -- see orderInPic, -- order
    of a line bundle of degree 0 in Pic(E)
  * "randomExtension(VectorBundleOnE,VectorBundleOnE)" -- see
    randomExtension, -- a random extension of a vector bundle
    on E by another vector bundle
  * "tensorProduct(CliffordModule,VectorBundleOnE)" -- see tensorProduct,
    -- tensor product of sheaves on the elliptic curve or sheaf
    times CliffordModule
  * "tensorProduct(VectorBundleOnE,VectorBundleOnE)" -- see
    tensorProduct, -- tensor product of sheaves on the elliptic
    curve or sheaf times CliffordModule
  * "translateIsotropicSubspace(CliffordModule,VectorBundleOnE,PolynomialRing)"
    -- see translateIsotropicSubspace, --
    choose a random isotropic subspace

For the programmer
==================

The object VectorBundleOnE, is a type (Macaulay2Doc),
with ancestor classes MutableHashTable (Macaulay2Doc),
< HashTable (Macaulay2Doc) <
Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2649:0.

vectorBundleOnE -- creates a VectorBundleOnE, represented as a matrix factorization
***********************************************************************************

  * Usage:
        V = vectorBundleOnE M
  * Inputs:
      * M, a matrix (Macaulay2Doc), -square matrix on PP^1,
        representing the action of y
  * Outputs:
      * V, an instance of the type VectorBundleOnE,

Description
===========

A vector bundle on a hyperelliptic curve E with equation y^2 - (-1)^g * f can
be represented by it's pushforward V to PP^1, under the degree 2 map, which
will be a vector bundle of twice the rank, together with a matrix M =
V.yAction, specifying the action of y. The matrix must therefore satisfy M^2 =
(-1)^g * f. Here f is the hyperellipticBranchEquation, a form on PP^1 of degree
2g+2

The following gives an example for g=1, constructing a random line bundle of
degree 0, and computing its order in the Picard group; and the producing a
random extension of this bundle by a random line bundle of order -1.

The random matrix factorization of f has the form

b c

a -b

where a is the lowest degree factor of f-b^2 (or f+b^2), depending on the
desired sign, and values of b are taken randomly until one giving a nontrivial
factorization over the given ground field is found. Note that this works well
over a finite field, but is unlikely to work over QQ.

+-----------------------------------------------------------------------------+
|i1 : setRandomSeed 0                                                         |
| -- setting random seed to 0                                                 |
|                                                                             |
|o1 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i2 : kk=ZZ/101                                                               |
|                                                                             |
|o2 = kk                                                                      |
|                                                                             |
|o2 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i3 : R = kk[s,t]                                                             |
|                                                                             |
|o3 = R                                                                       |
|                                                                             |
|o3 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i4 : f =(s+2*t)*(s+t)*(s-t)*(s-2*t)                                          |
|                                                                             |
|      4     2 2     4                                                        |
|o4 = s  - 5s t  + 4t                                                         |
|                                                                             |
|o4 : R                                                                       |
+-----------------------------------------------------------------------------+
|i5 : L0 = randomLineBundle(0,f)                                              |
|                                                                             |
|o5 = VectorBundleOnE{...1...}                                                |
|                                                                             |
|o5 : VectorBundleOnE                                                         |
+-----------------------------------------------------------------------------+
|i6 : (L0.yAction)^2                                                          |
|                                                                             |
|o6 = {-1} | s4-5s2t2+4t4 0            |                                      |
|     {-1} | 0            s4-5s2t2+4t4 |                                      |
|                                                                             |
|             2      2                                                        |
|o6 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+
|i7 : degOnE L0                                                               |
|                                                                             |
|o7 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i8 : orderInPic L0                                                           |
|                                                                             |
|o8 = 60                                                                      |
+-----------------------------------------------------------------------------+
|i9 : L1 = randomLineBundle(-1,f)                                             |
|                                                                             |
|o9 = VectorBundleOnE{...1...}                                                |
|                                                                             |
|o9 : VectorBundleOnE                                                         |
+-----------------------------------------------------------------------------+
|i10 : degOnE L1                                                              |
|                                                                             |
|o10 = -1                                                                     |
+-----------------------------------------------------------------------------+
|i11 : L1.yAction                                                             |
|                                                                             |
|o11 = {-2} | -10s2-29st-8t2 16s3-21s2t-2st2+41t3 |                           |
|      {-1} | 38s+t          10s2+29st+8t2        |                           |
|                                                                             |
|              2      2                                                       |
|o11 : Matrix R  <-- R                                                        |
+-----------------------------------------------------------------------------+
|i12 : F = randomExtension(L1,L0)                                             |
|                                                                             |
|o12 = VectorBundleOnE{...1...}                                               |
|                                                                             |
|o12 : VectorBundleOnE                                                        |
+-----------------------------------------------------------------------------+
|i13 : F.yAction                                                              |
|                                                                             |
|o13 = {-2} | -10s2-29st-8t2 16s3-21s2t-2st2+41t3 -30s3+24s2t-27st2-41t3      |
|      {-1} | 38s+t          10s2+29st+8t2        42s2-2st+22t2               |
|      {-1} | 0              0                    -29s2+19st+19t2             |
|      {-1} | 0              0                    47s2-22st+t2                |
|      -----------------------------------------------------------------------|
|      -22s3-16s2t-11st2-47t3 |                                               |
|      9s2+32st-48t2          |                                               |
|      38s2+9st+47t2          |                                               |
|      29s2-19st-19t2         |                                               |
|                                                                             |
|              4      4                                                       |
|o13 : Matrix R  <-- R                                                        |
+-----------------------------------------------------------------------------+
|i14 : degOnE tensorProduct(L1,F)                                             |
|                                                                             |
|o14 = -3                                                                     |
+-----------------------------------------------------------------------------+

See also
========

  * randomLineBundle -- a random balanced line bundle
    on the hyperelliptic curve
  * randomExtension -- a random extension of a vector
    bundle on E by another vector bundle
  * VectorBundleOnE -- vector bundle on a hyperelliptic
    curve E
  * yAction -- defines a vector bundle on E
  * degOnE -- degree of a vector bundle on E
  * orderInPic -- order of a line bundle of degree 0 in
    Pic(E)
  * tensorProduct -- tensor product of sheaves on the
    elliptic curve or sheaf times CliffordModule

Ways to use vectorBundleOnE:
============================

  * "vectorBundleOnE(Matrix)"

For the programmer
==================

The object vectorBundleOnE, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2858:0.

yAction -- defines a vector bundle on E
***************************************

  * Usage:
        M = V.yAction
  * Outputs:
      * M, a matrix (Macaulay2Doc), a square matrix on PP^1,
        representing the action of y

Description
===========

A matrix representing the action of y for the hyperelliptic curve E with
equation y^2 - (-1)^g * f.

+--------------------------------------------+
|i1 : setRandomSeed 0                        |
| -- setting random seed to 0                |
|                                            |
|o1 = 0                                      |
+--------------------------------------------+
|i2 : kk = ZZ/101;                           |
+--------------------------------------------+
|i3 : R = kk[s,t];                           |
+--------------------------------------------+
|i4 : f = (s+2*t)*(s+t)*(s-t)*(s-2*t);       |
+--------------------------------------------+
|i5 : L0 = randomLineBundle(0,f)             |
|                                            |
|o5 = VectorBundleOnE{...1...}               |
|                                            |
|o5 : VectorBundleOnE                        |
+--------------------------------------------+
|i6 : M = L0.yAction                         |
|                                            |
|o6 = {-1} | -29s2+19st+19t2 38s2+9st+47t2  ||
|     {-1} | 47s2-22st+t2    29s2-19st-19t2 ||
|                                            |
|             2      2                       |
|o6 : Matrix R  <-- R                        |
+--------------------------------------------+
|i7 : M^2 - f*id_(source M)                  |
|                                            |
|o7 = 0                                      |
|                                            |
|             2      2                       |
|o7 : Matrix R  <-- R                        |
+--------------------------------------------+

See also
========

  * randomLineBundle -- a random balanced line bundle
    on the hyperelliptic curve
  * randomExtension -- a random extension of a vector
    bundle on E by another vector bundle
  * vectorBundleOnE -- creates a VectorBundleOnE,
    represented as a matrix factorization
  * VectorBundleOnE -- vector bundle on a hyperelliptic
    curve E
  * degOnE -- degree of a vector bundle on E
  * orderInPic -- order of a line bundle of degree 0 in
    Pic(E)
  * tensorProduct -- tensor product of sheaves on the
    elliptic curve or sheaf times CliffordModule

For the programmer
==================

The object yAction, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in PencilsOfQuadrics.m2:2889:0.