This is OldToricVectorBundles.info, produced by Macaulay2, version 1.22

OldToricVectorBundles -- cohomology computations of equivariant vector bundles on toric varieties
*************************************************************************************************

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

Using the descriptions of Kaneyama and Klyachko this package implements the
construction of equivariant vector bundles on toric varieties.

Note that this package implements vector bundles in Kaneyama's description only
over pure and full dimensional fans.

OldToricVectorBundles uses the OldPolyhedra, package
by René Birkner (see http://page.mi.fu-berlin.de/rbirkner/indexen.htm ). At
least version 1.1 of OldPolyhedra, must be installed
via installPackage (Macaulay2Doc), to use
OldToricVectorBundles.

Each vector bundle is saved either in the description of Kaneyama or the one of
Klyachko. The first description gives the multidegrees (in the dual lattice of
the fan) of the generators of the bundle over each full dimensional cone, and
for each codimension-one cone a transition matrix (See
ToricVectorBundleKaneyama). The description of an
equivariant vector bundle given by Klyachko consists of filtrations of a fixed
vector space for each ray in the fan of the base variety. Furthermore, these
filtrations have to satisfy a certain compatibility condition (See
ToricVectorBundleKlyachko).

For the mathematical background see
  * Tamafumi Kaneyama,On equivariant vector bundles on an almost homogeneous
    variety, Nagoya Math. J. 57, 1975.
  * Alexander A. Klyachko,Equivariant bundles over toral varieties, Izv. Akad.
    Nauk SSSR Ser. Mat., 53, 1989.
  * Markus Perling,Resolution and moduli for equivariant sheaves over toric
    varieties, PhD Thesis, 2003.

See also
========

  * OldPolyhedra -- for computations with convex
    polyhedra, cones, and fans

Authors
=======

  * René Birkner (see http://page.mi.fu-berlin.de/rbirkner/indexen.htm )
    <rbirkner@math.fu-berlin.de>
  * Nathan Ilten (see http://people.cs.uchicago.edu/~nilten/ )
    <nilten@cs.uchicago.edu>
  * Lars Petersen <petersen@math.fu-berlin.de>

Certification a gold star
=========================

Version 1.0 of this package was accepted for publication in volume 2 (see
http://j-sag.org/Volume2/ ) of The Journal of Software for Algebra and
Geometry: Macaulay2 (see http://j-sag.org/ ) on 2010-06-15, in the article
Computations with equivariant toric vector bundles (see
http://j-sag.org/Volume2/jsag-3-2010.pdf ). That version can be obtained from
the journal (see http://j-sag.org/Volume2/ToricVectorBundles.m2 ) or from the
Macaulay2 source code repository (see
https://github.com/Macaulay2/M2/blob/314a1e7a1a5f612124f23e2161c58eabeb491f46/
M2/Macaulay2/packages/ToricVectorBundles.m2 ).

Version
=======

This documentation describes version 1.1 of OldToricVectorBundles.

Source code
===========

The source code from which this documentation is derived is in the file
OldToricVectorBundles.m2 (see common/share/Macaulay2/OldToricVectorBundles.m2
).

Exports
=======

  * Types
      * ToricVectorBundle -- the class of all toric
        vector bundles
      * ToricVectorBundleKaneyama -- the
        class of all toric vector bundles in Kaneyama's description
      * ToricVectorBundleKlyachko -- the
        class of all toric vector bundles in Klyachko's description
  * Functions and commands
      * addBase -- changing the basis matrices of a toric
        vector bundle in Klyachko's description
      * addBaseChange -- changing the transition matrices
        of a toric vector bundle
      * addDegrees -- changing the degrees of a toric vector
        bundle
      * addFiltration -- changing the filtration matrices
        of a toric vector bundle in Klyachko's description
      * areIsomorphic -- checks if two vector bundles are
        isomorphic
      * base --  the basis matrices for the rays
      * cartierIndex --  the Cartier index of a Weil
        divisor
      * charts --  the number of maximal affine charts
      * cocycleCheck --  checks if a toric vector bundle
        fulfills the cocycle condition
      * cotangentBundle --  the cotangent bundle on a
        toric variety
      * deltaE --  the polytope of possible degrees that give
        non zero cohomology
      * details --  the details of a toric vector bundle
      * eulerChi --  the Euler characteristic of a toric
        vector bundle
      * existsDecomposition --  checks if a list of
        matrices of weight vectors for each maximal cone admits a decomposition
      * filtration --  the filtration matrices of the vector
        bundle
      * findWeights --  finds the possible weight vectors
        for the maximal cones
      * hirzebruchFan -- the fan of the n-th Hirzebruch
        surface
      * isGeneral --  checks whether a toric vector bundle is
        general
      * isomorphism --  the isomorphism if the two bundles
        are isomorphic
      * isVectorBundle --  checks if the data does in
        fact define an equivariant toric vector bundle
      * pp1ProductFan -- the fan of n products of PP^1
      * projectiveSpaceFan -- the fan of projective
        n space
      * randomDeformation --  a random deformation of
        a given toric vector bundle
      * regCheck --  checking the regularity condition for a
        toric vector bundle
      * tangentBundle --  the tangent bundle on a toric
        variety
      * toricVectorBundle --  the trivial bundle of
        rank 'k' for a given fan
      * twist --  twists a toric vector bundle with a line bundle
      * weilToCartier --  the line bundle given by a
        Cartier divisor
  * Methods
      * "addBase(ToricVectorBundleKlyachko,List)" -- see addBase,
        -- changing the basis matrices of a toric vector bundle in
        Klyachko's description
      * "addBaseChange(ToricVectorBundleKaneyama,List)" -- see
        addBaseChange, -- changing the transition matrices of a
        toric vector bundle
      * "addDegrees(ToricVectorBundleKaneyama,List)" -- see addDegrees,
        -- changing the degrees of a toric vector bundle
      * "addFiltration(ToricVectorBundleKlyachko,List)" -- see
        addFiltration, -- changing the filtration matrices of a
        toric vector bundle in Klyachko's description
      * "areIsomorphic(ToricVectorBundleKlyachko,ToricVectorBundleKlyachko)" --
        see areIsomorphic, -- checks if two vector bundles
        are isomorphic
      * "base(ToricVectorBundleKlyachko)" -- see base, --  the
        basis matrices for the rays
      * "cartierIndex(List,Fan)" -- see cartierIndex, --
        the Cartier index of a Weil divisor
      * "charts(ToricVectorBundle)" -- see charts, --  the number
        of maximal affine charts
      * "cocycleCheck(ToricVectorBundleKaneyama)" -- see cocycleCheck,
        --  checks if a toric vector bundle fulfills the cocycle
        condition
      * cokernel(ToricVectorBundleKlyachko,Matrix)
        --  the cokernel of a
        morphism to a vector bundle
      * "cotangentBundle(Fan)" -- see cotangentBundle,
        --  the cotangent bundle on a toric variety
      * "deltaE(ToricVectorBundle)" -- see deltaE, --  the
        polytope of possible degrees that give non zero cohomology
      * "details(ToricVectorBundle)" -- see details, --  the
        details of a toric vector bundle
      * dual(ToricVectorBundle) --  the
        dual bundle of a toric vector bundle
      * "eulerChi(Matrix,ToricVectorBundle)" -- see eulerChi,
        --  the Euler characteristic of a toric vector bundle
      * "eulerChi(ToricVectorBundle)" -- see eulerChi, --  the
        Euler characteristic of a toric vector bundle
      * "existsDecomposition(ToricVectorBundleKlyachko,List)" -- see
        existsDecomposition, --  checks if a list of
        matrices of weight vectors for each maximal cone admits a decomposition
      * exteriorPower(ZZ,ToricVectorBundle)
        --  the 'l'-th exterior
        power of a toric vector bundle
      * fan(ToricVectorBundle) --  the
        underlying fan of a toric vector bundle
      * "filtration(ToricVectorBundleKlyachko)" -- see filtration,
        --  the filtration matrices of the vector bundle
      * "findWeights(ToricVectorBundleKlyachko)" -- see findWeights,
        --  finds the possible weight vectors for the maximal
        cones
      * HH^ZZ ToricVectorBundle --  the i-th
        cohomology group of a toric vector bundle
      * hh^ZZ ToricVectorBundle --  the rank of
        the i-th cohomology group of a toric vector bundle
      * HH^ZZ(ToricVectorBundle,List)
        --  the i-th cohomology of a toric
        vector bundle for a given list of degrees
      * HH^ZZ(ToricVectorBundle,Matrix)
        --  the i-th cohomology of a
        toric vector bundle in a given degree
      * "hirzebruchFan(ZZ)" -- see hirzebruchFan, -- the
        fan of the n-th Hirzebruch surface
      * image(ToricVectorBundleKlyachko,Matrix)
        --  the image of a
        vector bundle under a morphism
      * "isGeneral(ToricVectorBundleKlyachko)" -- see isGeneral,
        --  checks whether a toric vector bundle is general
      * "isomorphism(ToricVectorBundleKlyachko,ToricVectorBundleKlyachko)" --
        see isomorphism, --  the isomorphism if the two
        bundles are isomorphic
      * "isVectorBundle(ToricVectorBundle)" -- see isVectorBundle,
        --  checks if the data does in fact define an
        equivariant toric vector bundle
      * kernel(ToricVectorBundleKlyachko,Matrix)
        --  the kernel of a
        morphism to a vector bundle
      * maxCones(ToricVectorBundle), --
        the list of maximal cones of the underlying fan
      * net(ToricVectorBundleKaneyama)
        -- displays characteristics of a
        toric vector bundle
      * net(ToricVectorBundleKlyachko)
        -- displays characteristics of a
        toric vector bundle in Klyachko's description
      * "pp1ProductFan(ZZ)" -- see pp1ProductFan, -- the
        fan of n products of PP^1
      * "projectiveSpaceFan(ZZ)" -- see projectiveSpaceFan,
        -- the fan of projective n space
      * "randomDeformation(ToricVectorBundleKlyachko,ZZ)" -- see
        randomDeformation, --  a random deformation of a
        given toric vector bundle
      * "randomDeformation(ToricVectorBundleKlyachko,ZZ,ZZ)" -- see
        randomDeformation, --  a random deformation of a
        given toric vector bundle
      * rank(ToricVectorBundle) --  the
        rank of the vector bundle
      * rays(ToricVectorBundle) --  the
        rays of the underlying fan
      * "regCheck(ToricVectorBundleKaneyama)" -- see regCheck,
        --  checking the regularity condition for a toric vector bundle
      * ring(ToricVectorBundle) --  the
        graded ring of the bundle
      * symmetricPower(ZZ,ToricVectorBundle)
        --  the 'l'-th symmetric
        power of a toric vector bundle
      * "tangentBundle(Fan)" -- see tangentBundle, --  the
        tangent bundle on a toric variety
      * tensor(ToricVectorBundle,ToricVectorBundle)
        --  the tensor
        product of two toric vector bundles
      * "toricVectorBundle(ZZ,Fan)" -- see toricVectorBundle,
        --  the trivial bundle of rank 'k' for a given fan
      * ToricVectorBundle ** ToricVectorBundle
        --  the tensor product of two toric vector bundles
      * ToricVectorBundle ++ ToricVectorBundle
        --  the direct sum of two toric vector bundles
      * ToricVectorBundle == ToricVectorBundle
        --  checks for equality
      * toricVectorBundle(ZZ,Fan,List,List)
        --  a toric vector
        bundle of rank 'k' with given filtrations or degrees
      * "twist(ToricVectorBundleKlyachko,List)" -- see twist, --
        twists a toric vector bundle with a line bundle
      * "weilToCartier(List,Fan)" -- see weilToCartier, --
        the line bundle given by a Cartier divisor

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

The object OldToricVectorBundles, is a package (Macaulay2Doc).

addBase -- changing the basis matrices of a toric vector bundle in Klyachko's description
*****************************************************************************************

Synopsis
========

  * Usage:
        F = addBase(E,L)
  * Inputs:
      * E, a vector bundle on a toric variety (Klyachko's description),
      * L, a list (Macaulay2Doc), with matrices over ZZ (Macaulay2Doc),
        or QQ (Macaulay2Doc),
  * Outputs:
      * F, a vector bundle on a toric variety (Klyachko's description),

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

addBase replaces the basis matrices in E by the matrices in the List (Macaulay2Doc),
L. The matrices in L must be in GL($k,R$), where $k$ is the
rank of the vector bundle E and $R$ is ZZ (Macaulay2Doc), or QQ (Macaulay2Doc).
The list has to contain one matrix for each ray of the
underlying fan over which E is defined. Note that in E the rays are already
sorted and that the basis matrices in L will be assigned to the rays in that
order. To see the order use rays(ToricVectorBundle).

The matrices need not satisfy the compatibility condition. This can be checked
with isVectorBundle.
+-----------------------------------------------------------------------------+
|i1 : E = toricVectorBundle(2,pp1ProductFan 2)                                |
|                                                                             |
|o1 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      number of rays => 4                                                    |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o1 : ToricVectorBundleKlyachko                                               |
+-----------------------------------------------------------------------------+
|i2 : details E                                                               |
|                                                                             |
|o2 = HashTable{| -1 | => (| 1 0 |, 0)}                                       |
|               | 0  |     | 0 1 |                                            |
|               | 0  | => (| 1 0 |, 0)                                        |
|               | -1 |     | 0 1 |                                            |
|               | 0 | => (| 1 0 |, 0)                                         |
|               | 1 |     | 0 1 |                                             |
|               | 1 | => (| 1 0 |, 0)                                         |
|               | 0 |     | 0 1 |                                             |
|                                                                             |
|o2 : HashTable                                                               |
+-----------------------------------------------------------------------------+
|i3 : F = addBase(E,{matrix{{1,2},{3,1}},matrix{{-1,0},{3,1}},matrix{{1,2},{-3|
|                                                                             |
|o3 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      number of rays => 4                                                    |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o3 : ToricVectorBundleKlyachko                                               |
|-----------------------------------------------------------------------------|
|,-1}},matrix{{-1,0},{-3,-1}}})                                               |
+-----------------------------------------------------------------------------+
|i4 : details F                                                               |
|                                                                             |
|o4 = HashTable{| -1 | => (| 1  2  |, 0)}                                     |
|               | 0  |     | -3 -1 |                                          |
|               | 0  | => (| 1 2 |, 0)                                        |
|               | -1 |     | 3 1 |                                            |
|               | 0 | => (| -1 0 |, 0)                                        |
|               | 1 |     | 3  1 |                                            |
|               | 1 | => (| -1 0  |, 0)                                       |
|               | 0 |     | -3 -1 |                                           |
|                                                                             |
|o4 : HashTable                                                               |
+-----------------------------------------------------------------------------+
|i5 : isVectorBundle F                                                        |
|                                                                             |
|o5 = true                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * base --  the basis matrices for the rays
  * addFiltration -- changing the filtration matrices of
    a toric vector bundle in Klyachko's description
  * isVectorBundle --  checks if the data does in fact
    define an equivariant toric vector bundle

Ways to use addBase :
=====================

  * "addBase(ToricVectorBundleKlyachko,List)"

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

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

addBaseChange -- changing the transition matrices of a toric vector bundle
**************************************************************************

Synopsis
========

  * Usage:
        F = addBaseChange(E,L)
  * Inputs:
      * E, a vector bundle on a toric variety (Kaneyama's description),
      * L, a list (Macaulay2Doc), with matrices over ZZ (Macaulay2Doc),
        or QQ (Macaulay2Doc),
  * Outputs:
      * F, a vector bundle on a toric variety (Kaneyama's description),

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

addBaseChange replaces the transition matrices in E by the matrices in the
List (Macaulay2Doc), L. The matrices in L must be in GL($k$,see
ZZ (Macaulay2Doc)) or GL($k$,see QQ (Macaulay2Doc)), where $k$ is the
rank of the vector bundle T. The list has to contain one matrix for each
maximal dimensional cone of the underlying fan over which E is defined. The fan
can be recovered with fan(ToricVectorBundle).
The vector bundle already has a list of pairs
$(i,j)$ denoting the codim 1 intersections of two maximal cones with $i<j$ and
they are ordered in lexicographic order. The matrices will be assigned to the
pairs $(i,j)$ in that order. To see which codimension 1 cone corresponds to the
pair $(i,j)$ use details(ToricVectorBundle). The matrix $A$
assigned to $(i,j)$ denotes the transition $(e_i^1,...,e_i^k) =
(e_j^1,...,e_j^k)*A$. The matrices need not satisfy the regularity or the
cocycle condition. These can be checked with regCheck, and
cocycleCheck.
+-----------------------------------------------------------------------------+
|i1 : E = toricVectorBundle(2,pp1ProductFan 2,"Type" => "Kaneyama")           |
|                                                                             |
|o1 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o1 : ToricVectorBundleKaneyama                                               |
+-----------------------------------------------------------------------------+
|i2 : details E                                                               |
|                                                                             |
|o2 = (HashTable{0 => (| 1 0 |, 0)  }, HashTable{(0, 1) => | 1 0 |})          |
|                      | 0 1 |                             | 0 1 |            |
|                1 => (| 1 0  |, 0)              (0, 2) => | 1 0 |            |
|                      | 0 -1 |                            | 0 1 |            |
|                2 => (| -1 0 |, 0)              (1, 3) => | 1 0 |            |
|                      | 0  1 |                            | 0 1 |            |
|                3 => (| -1 0  |, 0)             (2, 3) => | 1 0 |            |
|                      | 0  -1 |                           | 0 1 |            |
|                                                                             |
|o2 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i3 : F = addBaseChange(E,{matrix{{1,2},{0,1}},matrix{{1,0},{3,1}},matrix{{1,-|
|                                                                             |
|o3 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o3 : ToricVectorBundleKaneyama                                               |
|-----------------------------------------------------------------------------|
|2},{0,1}},matrix{{1,0},{-3,1}}})                                             |
+-----------------------------------------------------------------------------+
|i4 : details F                                                               |
|                                                                             |
|o4 = (HashTable{0 => (| 1 0 |, 0)  }, HashTable{(0, 1) => | 1 2 | })         |
|                      | 0 1 |                             | 0 1 |            |
|                1 => (| 1 0  |, 0)              (0, 2) => | 1 0 |            |
|                      | 0 -1 |                            | 3 1 |            |
|                2 => (| -1 0 |, 0)              (1, 3) => | 1 -2 |           |
|                      | 0  1 |                            | 0 1  |           |
|                3 => (| -1 0  |, 0)             (2, 3) => | 1  0 |           |
|                      | 0  -1 |                           | -3 1 |           |
|                                                                             |
|o4 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i5 : cocycleCheck F                                                          |
|                                                                             |
|o5 = true                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * addDegrees -- changing the degrees of a toric vector
    bundle
  * regCheck --  checking the regularity condition for a toric
    vector bundle
  * cocycleCheck --  checks if a toric vector bundle
    fulfills the cocycle condition

Ways to use addBaseChange :
===========================

  * "addBaseChange(ToricVectorBundleKaneyama,List)"

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

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

addDegrees -- changing the degrees of a toric vector bundle
***********************************************************

Synopsis
========

  * Usage:
        F = addDegrees(E,L)
  * Inputs:
      * E, a vector bundle on a toric variety (Kaneyama's description),
      * L, a list (Macaulay2Doc), with matrices over ZZ (Macaulay2Doc),
  * Outputs:
      * F, a vector bundle on a toric variety (Kaneyama's description),

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

addDegrees replaces the degree matrices in E by the matrices in the List (Macaulay2Doc),
L. The matrices in L must be $n$ by $k$ matrices over
ZZ (Macaulay2Doc), where $k$ is the rank of the vector bundle E and $n$ is
the dimension of the underlying toric variety. The list has to contain one
matrix for each maximal dimensional cone of the underlying fan over which E is
defined. Note that in E the top dimensional cones are already sorted and that
the degree matrices in L will be assigned to the cones in that order. To find
out the order use maxCones(ToricVectorBundle).
The matrices need not satisfy the regularity
condition. This can be checked with regCheck.
+-----------------------------------------------------------------------------+
|i1 : E = toricVectorBundle(2,pp1ProductFan 2,"Type" => "Kaneyama")           |
|                                                                             |
|o1 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o1 : ToricVectorBundleKaneyama                                               |
+-----------------------------------------------------------------------------+
|i2 : details E                                                               |
|                                                                             |
|o2 = (HashTable{0 => (| 1 0 |, 0)  }, HashTable{(0, 1) => | 1 0 |})          |
|                      | 0 1 |                             | 0 1 |            |
|                1 => (| 1 0  |, 0)              (0, 2) => | 1 0 |            |
|                      | 0 -1 |                            | 0 1 |            |
|                2 => (| -1 0 |, 0)              (1, 3) => | 1 0 |            |
|                      | 0  1 |                            | 0 1 |            |
|                3 => (| -1 0  |, 0)             (2, 3) => | 1 0 |            |
|                      | 0  -1 |                           | 0 1 |            |
|                                                                             |
|o2 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i3 : F = addDegrees(E,{matrix{{1,2},{3,1}},matrix{{-1,0},{3,1}},matrix{{1,2  |
|                                                                             |
|o3 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o3 : ToricVectorBundleKaneyama                                               |
|-----------------------------------------------------------------------------|
|},{-3,-1}},matrix{{-1,0},{-3,-1}}})                                          |
+-----------------------------------------------------------------------------+
|i4 : details F                                                               |
|                                                                             |
|o4 = (HashTable{0 => (| 1 0 |, | 1 2 |)    }, HashTable{(0, 1) => | 1 0 |})  |
|                      | 0 1 |  | 3 1 |                            | 0 1 |    |
|                1 => (| 1 0  |, | -1 0 |)               (0, 2) => | 1 0 |    |
|                      | 0 -1 |  | 3  1 |                          | 0 1 |    |
|                2 => (| -1 0 |, | 1  2  |)              (1, 3) => | 1 0 |    |
|                      | 0  1 |  | -3 -1 |                         | 0 1 |    |
|                3 => (| -1 0  |, | -1 0  |)             (2, 3) => | 1 0 |    |
|                      | 0  -1 |  | -3 -1 |                        | 0 1 |    |
|                                                                             |
|o4 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i5 : regCheck F                                                              |
|                                                                             |
|o5 = false                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * addBaseChange -- changing the transition matrices of
    a toric vector bundle
  * regCheck --  checking the regularity condition for a toric
    vector bundle
  * cocycleCheck --  checks if a toric vector bundle
    fulfills the cocycle condition

Ways to use addDegrees :
========================

  * "addDegrees(ToricVectorBundleKaneyama,List)"

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

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

addFiltration -- changing the filtration matrices of a toric vector bundle in Klyachko's description
****************************************************************************************************

Synopsis
========

  * Usage:
        F = addFiltration(E,L)
  * Inputs:
      * E, a vector bundle on a toric variety (Klyachko's description),
      * L, a list (Macaulay2Doc), with matrices over ZZ (Macaulay2Doc),
  * Outputs:
      * F, a vector bundle on a toric variety (Klyachko's description),

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

addFiltration replaces the filtration matrices in E by the matrices in the
List (Macaulay2Doc), L. The matrices in L must be $1$ by $k$
matrices over ZZ (Macaulay2Doc), where $k$ is the rank of the vector
bundle E. The list has to contain one matrix for each ray of the underlying fan
over which E is defined. Note that in E the rays are already sorted and that
the filtration matrices in L will be assigned to the rays in that order. To see
the order, use rays(ToricVectorBundle).

"The filtration on the vector bundle over a ray is given by the filtration
matrix for this ray in the following way: The first index $j$, such that the
$i$-th basis vector in the basis over this ray appears in the $j$-th step of
the filtration, is the $i$-th entry of the filtration matrix. OR in other
words, the $j$-th step step in the filtration is given by all columns of the
basis matrix for which the corresponding entry in the filtration matrix is less
or equal to $j$."

The matrices need not satisfy the compatibility condition. This can be checked
with isVectorBundle.
+-----------------------------------------------------------------------------+
|i1 : E = toricVectorBundle(2,pp1ProductFan 2)                                |
|                                                                             |
|o1 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      number of rays => 4                                                    |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o1 : ToricVectorBundleKlyachko                                               |
+-----------------------------------------------------------------------------+
|i2 : details E                                                               |
|                                                                             |
|o2 = HashTable{| -1 | => (| 1 0 |, 0)}                                       |
|               | 0  |     | 0 1 |                                            |
|               | 0  | => (| 1 0 |, 0)                                        |
|               | -1 |     | 0 1 |                                            |
|               | 0 | => (| 1 0 |, 0)                                         |
|               | 1 |     | 0 1 |                                             |
|               | 1 | => (| 1 0 |, 0)                                         |
|               | 0 |     | 0 1 |                                             |
|                                                                             |
|o2 : HashTable                                                               |
+-----------------------------------------------------------------------------+
|i3 : F = addFiltration(E,{matrix{{1,3}},matrix{{-1,3}},matrix{{2,-3}},matrix |
|                                                                             |
|o3 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      number of rays => 4                                                    |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o3 : ToricVectorBundleKlyachko                                               |
|-----------------------------------------------------------------------------|
|{{0,-1}}})                                                                   |
+-----------------------------------------------------------------------------+
|i4 : details F                                                               |
|                                                                             |
|o4 = HashTable{| -1 | => (| 1 0 |, | 2 -3 |)}                                |
|               | 0  |     | 0 1 |                                            |
|               | 0  | => (| 1 0 |, | 1 3 |)                                  |
|               | -1 |     | 0 1 |                                            |
|               | 0 | => (| 1 0 |, | -1 3 |)                                  |
|               | 1 |     | 0 1 |                                             |
|               | 1 | => (| 1 0 |, | 0 -1 |)                                  |
|               | 0 |     | 0 1 |                                             |
|                                                                             |
|o4 : HashTable                                                               |
+-----------------------------------------------------------------------------+
|i5 : isVectorBundle F                                                        |
|                                                                             |
|o5 = true                                                                    |
+-----------------------------------------------------------------------------+

This means that for example over the first ray the first basis vector of the
filtration of F appears at the filtration step 1 and the second at 3.

See also
========

  * filtration --  the filtration matrices of the vector
    bundle
  * addBase -- changing the basis matrices of a toric vector
    bundle in Klyachko's description
  * isVectorBundle --  checks if the data does in fact
    define an equivariant toric vector bundle

Ways to use addFiltration :
===========================

  * "addFiltration(ToricVectorBundleKlyachko,List)"

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

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

areIsomorphic -- checks if two vector bundles are isomorphic
************************************************************

Synopsis
========

  * Usage:
        b = areIsomorphic(E,F)
  * Inputs:
      * E, a vector bundle on a toric variety (Klyachko's description),
      * F, a vector bundle on a toric variety (Klyachko's description),
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), whether E and F are
        isomorphic

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

E and F must be vector bundles over the same fan. Two equivariant vector
bundles in Klyachko's description are isomorphic if there exists a simultaneous
isomorphism for the filtered vector spaces of all rays. The method then returns
whether the bundles are isomorphic.
+---------------------------------------------+
|i1 : HF = hirzebruchFan 2                    |
|                                             |
|o1 = {ambient dimension => 2         }       |
|      number of generating cones => 4        |
|      number of rays => 4                    |
|      top dimension of the cones => 2        |
|                                             |
|o1 : Fan                                     |
+---------------------------------------------+
|i2 : E = exteriorPower(2, cotangentBundle HF)|
|                                             |
|o2 = {dimension of the variety => 2 }        |
|      number of affine charts => 4           |
|      number of rays => 4                    |
|      rank of the vector bundle => 1         |
|                                             |
|o2 : ToricVectorBundleKlyachko               |
+---------------------------------------------+
|i3 : F = weilToCartier({-1,-1,-1,-1},HF)     |
|                                             |
|o3 = {dimension of the variety => 2 }        |
|      number of affine charts => 4           |
|      number of rays => 4                    |
|      rank of the vector bundle => 1         |
|                                             |
|o3 : ToricVectorBundleKlyachko               |
+---------------------------------------------+
|i4 : areIsomorphic(E,F)                      |
|                                             |
|o4 = true                                    |
+---------------------------------------------+

To obtain the isomorphism, if two bundles are isomorphic use isomorphism.

See also
========

  * isomorphism --  the isomorphism if the two bundles are
    isomorphic
  * base --  the basis matrices for the rays
  * filtration --  the filtration matrices of the vector
    bundle
  * details --  the details of a toric vector bundle

Ways to use areIsomorphic :
===========================

  * "areIsomorphic(ToricVectorBundleKlyachko,ToricVectorBundleKlyachko)"

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

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

base --  the basis matrices for the rays
****************************************

Synopsis
========

  * Usage:
        b = base E
  * Inputs:
      * E, a vector bundle on a toric variety (Klyachko's description),
  * Outputs:
      * b, a hash table (Macaulay2Doc),

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

The basis of a toric vector bundle in Klyachko's description is given for each
ray as a square matrix of rank $k$ of the bundle. The output is a
HashTable (Macaulay2Doc), where the keys are the rays of the fan
given as one column matrices over ZZ (Macaulay2Doc), and for each ray
a $k$ by $k$ matrix over QQ (Macaulay2Doc), and $k$ is the rank of the
bundle.
+--------------------------------------+
|i1 : E = tangentBundle hirzebruchFan 3|
|                                      |
|o1 = {dimension of the variety => 2 } |
|      number of affine charts => 4    |
|      number of rays => 4             |
|      rank of the vector bundle => 2  |
|                                      |
|o1 : ToricVectorBundleKlyachko        |
+--------------------------------------+
|i2 : base E                           |
|                                      |
|o2 = HashTable{| -1 | => | -1 1/3 |}  |
|               | 3  |    | 3  0   |   |
|               | 0  | => | 0  1 |     |
|               | -1 |    | -1 0 |     |
|               | 0 | => | 0 1 |       |
|               | 1 |    | 1 0 |       |
|               | 1 | => | 1 0 |       |
|               | 0 |    | 0 1 |       |
|                                      |
|o2 : HashTable                        |
+--------------------------------------+

See also
========

  * addBase -- changing the basis matrices of a toric vector
    bundle in Klyachko's description
  * filtration --  the filtration matrices of the vector
    bundle
  * isVectorBundle --  checks if the data does in fact
    define an equivariant toric vector bundle

Ways to use base :
==================

  * "base(ToricVectorBundleKlyachko)"

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

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

cartierIndex --  the Cartier index of a Weil divisor
****************************************************

Synopsis
========

  * Usage:
        N = cartierIndex(L,F)
  * Inputs:
      * L, a list (Macaulay2Doc),
      * F, an instance of the type Fan (OldPolyhedra), a pure and
        full dimensional fan
  * Outputs:
      * N, an integer (Macaulay2Doc),

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

L must be a list of weights, exactly one for each ray of the fan. Then the
Cartier index is the smallest strictly positive natural number $N$ such that
$N$ times the Weil divisor is Cartier. If the Weil divisor defined by these
weights is not QQ (Macaulay2Doc),-Cartier, then $N$ would be infinity.
In this case cartierIndex returns an error. Otherwise it returns $N$.
+-----------------------------------------+
|i1 : F = fan posHull matrix {{1,5},{5,1}}|
|                                         |
|o1 = {ambient dimension => 2         }   |
|      number of generating cones => 1    |
|      number of rays => 2                |
|      top dimension of the cones => 2    |
|                                         |
|o1 : Fan                                 |
+-----------------------------------------+
|i2 : L = {2,2}                           |
|                                         |
|o2 = {2, 2}                              |
|                                         |
|o2 : List                                |
+-----------------------------------------+
|i3 : cartierIndex(L,F)                   |
|                                         |
|o3 = 3                                   |
+-----------------------------------------+

If we change the Weil divisor we get a different Cartier index:
+----------------------+
|i4 : L = {3,3}        |
|                      |
|o4 = {3, 3}           |
|                      |
|o4 : List             |
+----------------------+
|i5 : cartierIndex(L,F)|
|                      |
|o5 = 2                |
+----------------------+

See also
========

  * weilToCartier --  the line bundle given by a Cartier
    divisor

Ways to use cartierIndex :
==========================

  * "cartierIndex(List,Fan)"

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

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

charts --  the number of maximal affine charts
**********************************************

Synopsis
========

  * Usage:
        n = charts E
  * Inputs:
      * E, an instance of the type ToricVectorBundle,
  * Outputs:
      * n, an integer (Macaulay2Doc),

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

The function charts returns the number of maximal cones in the underlying fan,
i.e., the number of affine charts.
+----------------------------------------+
|i1 : E = cotangentBundle pp1ProductFan 3|
|                                        |
|o1 = {dimension of the variety => 3 }   |
|      number of affine charts => 8      |
|      number of rays => 6               |
|      rank of the vector bundle => 3    |
|                                        |
|o1 : ToricVectorBundleKlyachko          |
+----------------------------------------+
|i2 : charts E                           |
|                                        |
|o2 = 8                                  |
+----------------------------------------+

See also
========

  * Fan (OldPolyhedra) -- the class of all fans
  * fan(ToricVectorBundle) --  the
    underlying fan of a toric vector bundle

Ways to use charts :
====================

  * "charts(ToricVectorBundle)"

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

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

cocycleCheck --  checks if a toric vector bundle fulfills the cocycle condition
*******************************************************************************

Synopsis
========

  * Usage:
        b = cocycleCheck E
  * Inputs:
      * E, a vector bundle on a toric variety (Kaneyama's description),
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), whether E satisfies
        the cocyle condition

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

The transition matrices in E define an equivariant toric vector bundle if they
satisfy the cocycle condition. I.e. in this implementation of complete fans
this means that for every codimension 2 cone of the fan the cycle of transition
matrices of codimension 1 cones containing the codimension 2 cone gives the
identity when multiplied.
+-------------------------------------------------------------------+
|i1 : E = toricVectorBundle(2,pp1ProductFan 2,"Type" => "Kaneyama") |
|                                                                   |
|o1 = {dimension of the variety => 2 }                              |
|      number of affine charts => 4                                 |
|      rank of the vector bundle => 2                               |
|                                                                   |
|o1 : ToricVectorBundleKaneyama                                     |
+-------------------------------------------------------------------+
|i2 : details E                                                     |
|                                                                   |
|o2 = (HashTable{0 => (| 1 0 |, 0)  }, HashTable{(0, 1) => | 1 0 |})|
|                      | 0 1 |                             | 0 1 |  |
|                1 => (| 1 0  |, 0)              (0, 2) => | 1 0 |  |
|                      | 0 -1 |                            | 0 1 |  |
|                2 => (| -1 0 |, 0)              (1, 3) => | 1 0 |  |
|                      | 0  1 |                            | 0 1 |  |
|                3 => (| -1 0  |, 0)             (2, 3) => | 1 0 |  |
|                      | 0  -1 |                           | 0 1 |  |
|                                                                   |
|o2 : Sequence                                                      |
+-------------------------------------------------------------------+
|i3 : A = matrix{{1,2},{0,1}};                                      |
|                                                                   |
|              2        2                                           |
|o3 : Matrix ZZ  <--- ZZ                                            |
+-------------------------------------------------------------------+
|i4 : B = matrix{{1,0},{3,1}};                                      |
|                                                                   |
|              2        2                                           |
|o4 : Matrix ZZ  <--- ZZ                                            |
+-------------------------------------------------------------------+
|i5 : C = matrix{{1,-2},{0,1}};                                     |
|                                                                   |
|              2        2                                           |
|o5 : Matrix ZZ  <--- ZZ                                            |
+-------------------------------------------------------------------+
|i6 : E1 = addBaseChange(E,{A,B,C,matrix{{1,0},{0,1}}})             |
|                                                                   |
|o6 = {dimension of the variety => 2 }                              |
|      number of affine charts => 4                                 |
|      rank of the vector bundle => 2                               |
|                                                                   |
|o6 : ToricVectorBundleKaneyama                                     |
+-------------------------------------------------------------------+
|i7 : cocycleCheck E1                                               |
|                                                                   |
|o7 = false                                                         |
+-------------------------------------------------------------------+
|i8 : D = inverse(B)*A*C                                            |
|                                                                   |
|o8 = | 1  0 |                                                      |
|     | -3 1 |                                                      |
|                                                                   |
|              2        2                                           |
|o8 : Matrix ZZ  <--- ZZ                                            |
+-------------------------------------------------------------------+
|i9 : E1 = addBaseChange(E,{A,B,C,D})                               |
|                                                                   |
|o9 = {dimension of the variety => 2 }                              |
|      number of affine charts => 4                                 |
|      rank of the vector bundle => 2                               |
|                                                                   |
|o9 : ToricVectorBundleKaneyama                                     |
+-------------------------------------------------------------------+
|i10 : cocycleCheck E1                                              |
|                                                                   |
|o10 = true                                                         |
+-------------------------------------------------------------------+

See also
========

  * addBaseChange -- changing the transition matrices of
    a toric vector bundle
  * addDegrees -- changing the degrees of a toric vector
    bundle
  * regCheck --  checking the regularity condition for a toric
    vector bundle

Ways to use cocycleCheck :
==========================

  * "cocycleCheck(ToricVectorBundleKaneyama)"

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

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

cokernel(ToricVectorBundleKlyachko,Matrix) --  the cokernel of a morphism to a vector bundle
********************************************************************************************

Synopsis
========

  * Function: cokernel (Macaulay2Doc),
  * Usage:
        E1 = coker(E,M)
  * Inputs:
      * E, a vector bundle on a toric variety (Klyachko's description),
      * M, a matrix (Macaulay2Doc), over ZZ (Macaulay2Doc),
        or QQ (Macaulay2Doc),
  * Outputs:
      * E1, a vector bundle on a toric variety (Klyachko's description),

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

M must be a matrix over ZZ (Macaulay2Doc), or QQ (Macaulay2Doc),
where the target space is the space of the bundle, i.e., the
matrix must have $k$ rows if the bundle has rank $k$. Then the new bundle is
given on each ray $\rho$ by the following filtration of coker(E,M)${}^\rho = (
E^{\rho} ) / $im(M) :

coker(E,M)${}^\rho(i) := E^{\rho}(i) / ( E^{\rho}(i) \cap $ im(M) ).
+---------------------------------------------------+
|i1 : E = tangentBundle hirzebruchFan 2             |
|                                                   |
|o1 = {dimension of the variety => 2 }              |
|      number of affine charts => 4                 |
|      number of rays => 4                          |
|      rank of the vector bundle => 2               |
|                                                   |
|o1 : ToricVectorBundleKlyachko                     |
+---------------------------------------------------+
|i2 : E = E ** E                                    |
|                                                   |
|o2 = {dimension of the variety => 2 }              |
|      number of affine charts => 4                 |
|      number of rays => 4                          |
|      rank of the vector bundle => 4               |
|                                                   |
|o2 : ToricVectorBundleKlyachko                     |
+---------------------------------------------------+
|i3 : M = matrix {{1,0},{0,1},{1,0},{0,1/1}}        |
|                                                   |
|o3 = | 1 0 |                                       |
|     | 0 1 |                                       |
|     | 1 0 |                                       |
|     | 0 1 |                                       |
|                                                   |
|              4        2                           |
|o3 : Matrix QQ  <--- QQ                            |
+---------------------------------------------------+
|i4 : E1 = coker(E,M)                               |
|                                                   |
|o4 = {dimension of the variety => 2 }              |
|      number of affine charts => 4                 |
|      number of rays => 4                          |
|      rank of the vector bundle => 2               |
|                                                   |
|o4 : ToricVectorBundleKlyachko                     |
+---------------------------------------------------+
|i5 : details E1                                    |
|                                                   |
|o5 = HashTable{| -1 | => (| -1/2 1/2 |, | -2 -1 |)}|
|               | 2  |     | 1    0   |             |
|               | 0  | => (| 0 1 |, | -2 -1 |)      |
|               | -1 |     | 1 0 |                  |
|               | 0 | => (| 0 1 |, | -2 -1 |)       |
|               | 1 |     | 1 0 |                   |
|               | 1 | => (| 1 0 |, | -2 -1 |)       |
|               | 0 |     | 0 1 |                   |
|                                                   |
|o5 : HashTable                                     |
+---------------------------------------------------+

See also
========

  * image(ToricVectorBundleKlyachko,Matrix)
    --  the image of a vector
    bundle under a morphism
  * kernel(ToricVectorBundleKlyachko,Matrix)
    --  the kernel of a
    morphism to a vector bundle

Ways to use this method:
========================

  * cokernel(ToricVectorBundleKlyachko,Matrix)
    --  the cokernel of a
    morphism to a vector bundle

cotangentBundle --  the cotangent bundle on a toric variety
***********************************************************

Synopsis
========

  * Usage:
        E = cotangentBundle F
  * Inputs:
      * F, an instance of the type Fan (OldPolyhedra),
  * Optional inputs (Macaulay2Doc),:
      * Type
  * Outputs:
      * E, a vector bundle on a toric variety (Kaneyama's description),
        or a vector bundle on a toric variety (Klyachko's description),

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

If the fan F is pure, of full dimension and smooth, then the function generates
the cotangent bundle of the toric variety given by F. If no further options are
given then the resulting bundle will be in Klyachko's description:
+-----------------------------------------------+
|i1 : F = projectiveSpaceFan 2                  |
|                                               |
|o1 = {ambient dimension => 2         }         |
|      number of generating cones => 3          |
|      number of rays => 3                      |
|      top dimension of the cones => 2          |
|                                               |
|o1 : Fan                                       |
+-----------------------------------------------+
|i2 : E = tangentBundle F                       |
|                                               |
|o2 = {dimension of the variety => 2 }          |
|      number of affine charts => 3             |
|      number of rays => 3                      |
|      rank of the vector bundle => 2           |
|                                               |
|o2 : ToricVectorBundleKlyachko                 |
+-----------------------------------------------+
|i3 : details E                                 |
|                                               |
|o3 = HashTable{| -1 | => (| -1 -1 |, | -1 0 |)}|
|               | -1 |     | -1 0  |            |
|               | 0 | => (| 0 1 |, | -1 0 |)    |
|               | 1 |     | 1 0 |               |
|               | 1 | => (| 1 0 |, | -1 0 |)    |
|               | 0 |     | 0 1 |               |
|                                               |
|o3 : HashTable                                 |
+-----------------------------------------------+

If the option "Type" => "Kaneyama" is given then the resulting bundle will be
in Kaneyama's description:
+--------------------------------------------------------------------------+
|i4 : F = projectiveSpaceFan 2                                             |
|                                                                          |
|o4 = {ambient dimension => 2         }                                    |
|      number of generating cones => 3                                     |
|      number of rays => 3                                                 |
|      top dimension of the cones => 2                                     |
|                                                                          |
|o4 : Fan                                                                  |
+--------------------------------------------------------------------------+
|i5 : E = tangentBundle(F,"Type" => "Kaneyama")                            |
|                                                                          |
|o5 = {dimension of the variety => 2 }                                     |
|      number of affine charts => 3                                        |
|      rank of the vector bundle => 2                                      |
|                                                                          |
|o5 : ToricVectorBundleKaneyama                                            |
+--------------------------------------------------------------------------+
|i6 : details E                                                            |
|                                                                          |
|o6 = (HashTable{0 => (| -1 0 |, | 1 1  |)}, HashTable{(0, 1) => | -1 0 |})|
|                      | -1 1 |  | 0 -1 |                        | -1 1 |  |
|                1 => (| 1 0 |, | -1 0  |)             (0, 2) => | 1 -1 |  |
|                      | 0 1 |  | 0  -1 |                        | 0 -1 |  |
|                2 => (| 1 -1 |, | 0 -1 |)             (1, 2) => | 0 -1 |  |
|                      | 0 -1 |  | 1 1  |                        | 1 -1 |  |
|                                                                          |
|o6 : Sequence                                                             |
+--------------------------------------------------------------------------+

See also
========

  * tangentBundle --  the tangent bundle on a toric
    variety

Ways to use cotangentBundle :
=============================

  * "cotangentBundle(Fan)"

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

The object cotangentBundle, is a method function with options (Macaulay2Doc).

deltaE --  the polytope of possible degrees that give non zero cohomology
*************************************************************************

Synopsis
========

  * Usage:
        P = deltaE E
  * Inputs:
      * E, an instance of the type ToricVectorBundle,
  * Outputs:
      * P, a convex polyhedron (OldPolyhedra),

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

For a toric vector bundle over a complete toric variety there is a finite set
of degrees $u$ such that the degree $u$ part of the cohomology of the vector
bundle is non-zero. This function computes a polytope $\Delta_E$, such that
these degrees are contained in this polytope. If the underlying toric variety
is not complete then an error is returned.
+-------------------------------------------------------------------+
|i1 : E = toricVectorBundle(2,pp1ProductFan 2, "Type" => "Kaneyama")|
|                                                                   |
|o1 = {dimension of the variety => 2 }                              |
|      number of affine charts => 4                                 |
|      rank of the vector bundle => 2                               |
|                                                                   |
|o1 : ToricVectorBundleKaneyama                                     |
+-------------------------------------------------------------------+
|i2 : P = deltaE E                                                  |
|                                                                   |
|o2 = {ambient dimension => 2           }                           |
|      dimension of lineality space => 0                            |
|      dimension of polyhedron => 0                                 |
|      number of facets => 0                                        |
|      number of rays => 0                                          |
|      number of vertices => 1                                      |
|                                                                   |
|o2 : Polyhedron                                                    |
+-------------------------------------------------------------------+
|i3 : vertices P                                                    |
|                                                                   |
|o3 = 0                                                             |
|                                                                   |
|              2        1                                           |
|o3 : Matrix QQ  <--- QQ                                            |
+-------------------------------------------------------------------+
|i4 : E1 = tangentBundle projectiveSpaceFan 2                       |
|                                                                   |
|o4 = {dimension of the variety => 2 }                              |
|      number of affine charts => 3                                 |
|      number of rays => 3                                          |
|      rank of the vector bundle => 2                               |
|                                                                   |
|o4 : ToricVectorBundleKlyachko                                     |
+-------------------------------------------------------------------+
|i5 : P1 = deltaE E1                                                |
|                                                                   |
|o5 = {ambient dimension => 2           }                           |
|      dimension of lineality space => 0                            |
|      dimension of polyhedron => 2                                 |
|      number of facets => 6                                        |
|      number of rays => 0                                          |
|      number of vertices => 6                                      |
|                                                                   |
|o5 : Polyhedron                                                    |
+-------------------------------------------------------------------+
|i6 : vertices P1                                                   |
|                                                                   |
|o6 = | -1 1 0  1  0 -1 |                                           |
|     | 0  0 -1 -1 1 1  |                                           |
|                                                                   |
|              2        6                                           |
|o6 : Matrix QQ  <--- QQ                                            |
+-------------------------------------------------------------------+

See also
========

  * eulerChi --  the Euler characteristic of a toric vector
    bundle
  * HH^ZZ ToricVectorBundle --  the i-th
    cohomology group of a toric vector bundle
  * hh^ZZ ToricVectorBundle --  the rank of the
    i-th cohomology group of a toric vector bundle

Ways to use deltaE :
====================

  * "deltaE(ToricVectorBundle)"

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

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

details --  the details of a toric vector bundle
************************************************

Synopsis
========

  * Usage:
        ht = details E
  * Inputs:
      * E, an instance of the type ToricVectorBundle,
  * Outputs:
      * ht, a sequence (Macaulay2Doc),  or HashTable (Macaulay2Doc),
        if the bundle is in Klyachko's description

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

For a toric vector bundle in Kaneyama's description, the sequence ht contains a
hash table that assigns to each maximal cone $\sigma$ of the underlying fan its
matrix of rays and its matrix of degrees, and a hash table giving a transition
matrix for every pair of maximal cones that intersect in a codimension 1 face.
+--------------------------------------------------------------------------+
|i1 : E = tangentBundle(pp1ProductFan 2,"Type" => "Kaneyama")              |
|                                                                          |
|o1 = {dimension of the variety => 2 }                                     |
|      number of affine charts => 4                                        |
|      rank of the vector bundle => 2                                      |
|                                                                          |
|o1 : ToricVectorBundleKaneyama                                            |
+--------------------------------------------------------------------------+
|i2 : details E                                                            |
|                                                                          |
|o2 = (HashTable{0 => (| 1 0 |, | -1 0  |)}, HashTable{(0, 1) => | 1 0  |})|
|                      | 0 1 |  | 0  -1 |                        | 0 -1 |  |
|                1 => (| 1 0  |, | -1 0 |)             (0, 2) => | -1 0 |  |
|                      | 0 -1 |  | 0  1 |                        | 0  1 |  |
|                2 => (| -1 0 |, | 1 0  |)             (1, 3) => | -1 0 |  |
|                      | 0  1 |  | 0 -1 |                        | 0  1 |  |
|                3 => (| -1 0  |, | 1 0 |)             (2, 3) => | 1 0  |  |
|                      | 0  -1 |  | 0 1 |                        | 0 -1 |  |
|                                                                          |
|o2 : Sequence                                                             |
+--------------------------------------------------------------------------+

For a toric vector bundle in Klyachko's description, the hash table ht contains
the rays of the underlying fan and for each ray the basis of the bundle over
this ray and the filtration matrix.
+----------------------------------------------+
|i3 : E = tangentBundle pp1ProductFan 2        |
|                                              |
|o3 = {dimension of the variety => 2 }         |
|      number of affine charts => 4            |
|      number of rays => 4                     |
|      rank of the vector bundle => 2          |
|                                              |
|o3 : ToricVectorBundleKlyachko                |
+----------------------------------------------+
|i4 : details E                                |
|                                              |
|o4 = HashTable{| -1 | => (| -1 0 |, | -1 0 |)}|
|               | 0  |     | 0  1 |            |
|               | 0  | => (| 0  1 |, | -1 0 |) |
|               | -1 |     | -1 0 |            |
|               | 0 | => (| 0 1 |, | -1 0 |)   |
|               | 1 |     | 1 0 |              |
|               | 1 | => (| 1 0 |, | -1 0 |)   |
|               | 0 |     | 0 1 |              |
|                                              |
|o4 : HashTable                                |
+----------------------------------------------+

Ways to use details :
=====================

  * "details(ToricVectorBundle)"

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

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

dual(ToricVectorBundle) --  the dual bundle of a toric vector bundle
********************************************************************

Synopsis
========

  * Function: dual (Macaulay2Doc),
  * Usage:
        Ed = dual E
  * Inputs:
      * E, an instance of the type ToricVectorBundle,
  * Outputs:
      * Ed, an instance of the type ToricVectorBundle,

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

dual computes the dual vector bundle of a toric vector bundle.
+----------------------------------------------------------------------------+
|i1 : E = tangentBundle(pp1ProductFan 2,"Type" => "Kaneyama")                |
|                                                                            |
|o1 = {dimension of the variety => 2 }                                       |
|      number of affine charts => 4                                          |
|      rank of the vector bundle => 2                                        |
|                                                                            |
|o1 : ToricVectorBundleKaneyama                                              |
+----------------------------------------------------------------------------+
|i2 : Ed = dual E                                                            |
|                                                                            |
|o2 = {dimension of the variety => 2 }                                       |
|      number of affine charts => 4                                          |
|      rank of the vector bundle => 2                                        |
|                                                                            |
|o2 : ToricVectorBundleKaneyama                                              |
+----------------------------------------------------------------------------+
|i3 : details Ed                                                             |
|                                                                            |
|o3 = (HashTable{0 => (| 1 0 |, | 1 0 |)    }, HashTable{(0, 1) => | 1 0  |})|
|                      | 0 1 |  | 0 1 |                            | 0 -1 |  |
|                1 => (| 1 0  |, | 1 0  |)               (0, 2) => | -1 0 |  |
|                      | 0 -1 |  | 0 -1 |                          | 0  1 |  |
|                2 => (| -1 0 |, | -1 0 |)               (1, 3) => | -1 0 |  |
|                      | 0  1 |  | 0  1 |                          | 0  1 |  |
|                3 => (| -1 0  |, | -1 0  |)             (2, 3) => | 1 0  |  |
|                      | 0  -1 |  | 0  -1 |                        | 0 -1 |  |
|                                                                            |
|o3 : Sequence                                                               |
+----------------------------------------------------------------------------+
|i4 : Ed == cotangentBundle(pp1ProductFan 2,"Type" => "Kaneyama")            |
|                                                                            |
|o4 = true                                                                   |
+----------------------------------------------------------------------------+
+-----------------------------------------------+
|i5 : E = tangentBundle projectiveSpaceFan 2    |
|                                               |
|o5 = {dimension of the variety => 2 }          |
|      number of affine charts => 3             |
|      number of rays => 3                      |
|      rank of the vector bundle => 2           |
|                                               |
|o5 : ToricVectorBundleKlyachko                 |
+-----------------------------------------------+
|i6 : Ed = dual E                               |
|                                               |
|o6 = {dimension of the variety => 2 }          |
|      number of affine charts => 3             |
|      number of rays => 3                      |
|      rank of the vector bundle => 2           |
|                                               |
|o6 : ToricVectorBundleKlyachko                 |
+-----------------------------------------------+
|i7 : details Ed                                |
|                                               |
|o7 = HashTable{| -1 | => (| 0  -1 |, | 1 0 |)} |
|               | -1 |     | -1 1  |            |
|               | 0 | => (| 0 1 |, | 1 0 |)     |
|               | 1 |     | 1 0 |               |
|               | 1 | => (| 1 0 |, | 1 0 |)     |
|               | 0 |     | 0 1 |               |
|                                               |
|o7 : HashTable                                 |
+-----------------------------------------------+
|i8 : Ed == cotangentBundle projectiveSpaceFan 2|
|                                               |
|o8 = true                                      |
+-----------------------------------------------+

See also
========

  * tangentBundle --  the tangent bundle on a toric
    variety
  * cotangentBundle --  the cotangent bundle on a toric
    variety

Ways to use this method:
========================

  * dual(ToricVectorBundle) --  the dual
    bundle of a toric vector bundle

eulerChi --  the Euler characteristic of a toric vector bundle
**************************************************************

Synopsis
========

  * Usage:
        i = eulerChi E
        eulerChi(u,E)
  * Inputs:
      * E, an instance of the type ToricVectorBundle,
      * u, a matrix (Macaulay2Doc), with just one column over
        ZZ (Macaulay2Doc), representing a degree vector
  * Outputs:
      * i, an integer (Macaulay2Doc),

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

This function computes the Euler characteristic of a vector bundle if only the
bundle is given to the function. For this it first computes the set of all
degrees that give non-zero cohomology (see deltaE) and then
computes the Euler characteristic for each these degrees. If the underlying
variety is not complete then this set may not be finite. Thus, for a
non-complete toric variety an error is returned.

If in addition a one-column matrix over ZZ (Macaulay2Doc),
representing a degree vector u, is given, it computes the Euler characteristic
of the degree u-part of the vector bundle E. For this the variety need not be
complete.
+--------------------------------------+
|i1 : E = tangentBundle hirzebruchFan 3|
|                                      |
|o1 = {dimension of the variety => 2 } |
|      number of affine charts => 4    |
|      number of rays => 4             |
|      rank of the vector bundle => 2  |
|                                      |
|o1 : ToricVectorBundleKlyachko        |
+--------------------------------------+
|i2 : u = matrix {{0},{0}}             |
|                                      |
|o2 = 0                                |
|                                      |
|              2        1              |
|o2 : Matrix ZZ  <--- ZZ               |
+--------------------------------------+
|i3 : eulerChi(u,E)                    |
|                                      |
|o3 = 2                                |
+--------------------------------------+
|i4 : eulerChi E                       |
|                                      |
|o4 = 6                                |
+--------------------------------------+
+------------------------------------------------------------+
|i5 : E = tangentBundle(hirzebruchFan 3,"Type" => "Kaneyama")|
|                                                            |
|o5 = {dimension of the variety => 2 }                       |
|      number of affine charts => 4                          |
|      rank of the vector bundle => 2                        |
|                                                            |
|o5 : ToricVectorBundleKaneyama                              |
+------------------------------------------------------------+
|i6 : u = matrix {{0},{0}}                                   |
|                                                            |
|o6 = 0                                                      |
|                                                            |
|              2        1                                    |
|o6 : Matrix ZZ  <--- ZZ                                     |
+------------------------------------------------------------+
|i7 : eulerChi(u,E)                                          |
|                                                            |
|o7 = 2                                                      |
+------------------------------------------------------------+
|i8 : eulerChi E                                             |
|                                                            |
|o8 = 6                                                      |
+------------------------------------------------------------+

See also
========

  * deltaE --  the polytope of possible degrees that give non
    zero cohomology
  * HH^ZZ ToricVectorBundle --  the i-th
    cohomology group of a toric vector bundle
  * hh^ZZ ToricVectorBundle --  the rank of the
    i-th cohomology group of a toric vector bundle

Ways to use eulerChi :
======================

  * "eulerChi(Matrix,ToricVectorBundle)"
  * "eulerChi(ToricVectorBundle)"

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

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

existsDecomposition --  checks if a list of matrices of weight vectors for each maximal cone admits a decomposition
*******************************************************************************************************************

Synopsis
========

  * Usage:
        b = existsDecomposition(E,L)
  * Inputs:
      * E, a vector bundle on a toric variety (Klyachko's description),
      * L, a list (Macaulay2Doc),
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), whether there exists
        a decomposition

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

The list L must have one entry for each maximal cone $\sigma$ in the underlying
fan $\Sigma$ of E. If the rank of the bundle is $k$ and the ambient dimension
of the variety is $n$ then each entry must either be an $n$ by $k$ matrix over
ZZ (Macaulay2Doc), or a list of these. Then it checks for each maximal
cone in the fan (given in the order of maxCones(ToricVectorBundle))
if for any of the matrices in the
corresponding entry in L these weight vectors admit a decomposition of the
bundle into torus eigenspaces. See Sam Payne's (see
http://math.stanford.edu/~sampayne/ ) Moduli of toric vector bundles,
Compositio Math. 144, 2008. Lemma 3.5.

One can for example use the output of the function findWeights.
+-----------------------------------------------------------------------------+
|i1 : E = tangentBundle projectiveSpaceFan 3                                  |
|                                                                             |
|o1 = {dimension of the variety => 3 }                                        |
|      number of affine charts => 4                                           |
|      number of rays => 4                                                    |
|      rank of the vector bundle => 3                                         |
|                                                                             |
|o1 : ToricVectorBundleKlyachko                                               |
+-----------------------------------------------------------------------------+
|i2 : L = findWeights E                                                       |
|                                                                             |
|o2 = {{| 1  1 1  |, | 1  1  1 |}, {| -1 0 0  |, | -1 0  0 |}, {| -1 0  0  |, |
|       | -1 0 0  |  | -1 0  0 |    | 1  1 1  |  | 1  1  1 |    | 0  -1 0  |  |
|       | 0  0 -1 |  | 0  -1 0 |    | 0  0 -1 |  | 0  -1 0 |    | 0  0  -1 |  |
|     ------------------------------------------------------------------------|
|     | -1 0  0  |}, {| -1 0  0 |, | -1 0 0  |}}                              |
|     | 0  0  -1 |    | 0  -1 0 |  | 0  0 -1 |                                |
|     | 0  -1 0  |    | 1  1  1 |  | 1  1 1  |                                |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : existsDecomposition(E,L)                                                |
|                                                                             |
|o3 = true                                                                    |
+-----------------------------------------------------------------------------+

Note that the data given in the description of E defines an equivariant vector
bundle on the toric variety exactly if there exists a set of weight vectors for
each maximal cone that admits a decomposition. The function
isVectorBundle, uses this.

See also
========

  * findWeights --  finds the possible weight vectors for
    the maximal cones
  * isVectorBundle --  checks if the data does in fact
    define an equivariant toric vector bundle
  * maxCones(ToricVectorBundle) --  the
    list of maximal cones of the underlying fan

Ways to use existsDecomposition :
=================================

  * "existsDecomposition(ToricVectorBundleKlyachko,List)"

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

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

exteriorPower(ZZ,ToricVectorBundle) --  the 'l'-th exterior power of a toric vector bundle
******************************************************************************************

Synopsis
========

  * Function: exteriorPower (Macaulay2Doc),
  * Usage:
        Ee = exteriorPower(l,E)
  * Inputs:
      * l, an integer (Macaulay2Doc),  strictly positive
      * E, an instance of the type ToricVectorBundle,
  * Optional inputs (Macaulay2Doc),:
      * Strategy (Macaulay2Doc),
        => ..., default value null, null
  * Outputs:
      * Ee, an instance of the type ToricVectorBundle,

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

exteriorPower computes the l-th exterior power of a toric vector bundle in each
description. The resulting bundle will be given in the same description as the
original bundle. l must be strictly positive and at most equal the rank of the
bundle.
+------------------------------------------------+
|i1 : E = tangentBundle hirzebruchFan 3          |
|                                                |
|o1 = {dimension of the variety => 2 }           |
|      number of affine charts => 4              |
|      number of rays => 4                       |
|      rank of the vector bundle => 2            |
|                                                |
|o1 : ToricVectorBundleKlyachko                  |
+------------------------------------------------+
|i2 : details E                                  |
|                                                |
|o2 = HashTable{| -1 | => (| -1 1/3 |, | -1 0 |)}|
|               | 3  |     | 3  0   |            |
|               | 0  | => (| 0  1 |, | -1 0 |)   |
|               | -1 |     | -1 0 |              |
|               | 0 | => (| 0 1 |, | -1 0 |)     |
|               | 1 |     | 1 0 |                |
|               | 1 | => (| 1 0 |, | -1 0 |)     |
|               | 0 |     | 0 1 |                |
|                                                |
|o2 : HashTable                                  |
+------------------------------------------------+
|i3 : Ee = exteriorPower(2,E)                    |
|                                                |
|o3 = {dimension of the variety => 2 }           |
|      number of affine charts => 4              |
|      number of rays => 4                       |
|      rank of the vector bundle => 1            |
|                                                |
|o3 : ToricVectorBundleKlyachko                  |
+------------------------------------------------+
|i4 : details Ee                                 |
|                                                |
|o4 = HashTable{| -1 | => (| -1 |, | -1 |)}      |
|               | 3  |                           |
|               | 0  | => (| 1 |, | -1 |)        |
|               | -1 |                           |
|               | 0 | => (| -1 |, | -1 |)        |
|               | 1 |                            |
|               | 1 | => (| 1 |, | -1 |)         |
|               | 0 |                            |
|                                                |
|o4 : HashTable                                  |
+------------------------------------------------+

See also
========

  * ToricVectorBundle ++ ToricVectorBundle
    --  the direct sum of two toric vector bundles
  * tensor(ToricVectorBundle,ToricVectorBundle)
    --  the tensor product
    of two toric vector bundles
  * symmetricPower(ZZ,ToricVectorBundle)
    --  the 'l'-th symmetric power
    of a toric vector bundle

Ways to use this method:
========================

  * exteriorPower(ZZ,ToricVectorBundle)
    --  the 'l'-th exterior power of
    a toric vector bundle

fan(ToricVectorBundle) --  the underlying fan of a toric vector bundle
**********************************************************************

Synopsis
========

  * Function: fan (OldPolyhedra),
  * Usage:
        F = fan E
  * Inputs:
      * E, an instance of the type ToricVectorBundle,
  * Outputs:
      * F, an instance of the type Fan (OldPolyhedra),

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

Returns the fan of the underlying toric variety. This is an object of the
package OldPolyhedra. See also Fan (OldPolyhedra).
+--------------------------------------+
|i1 : E = tangentBundle hirzebruchFan 3|
|                                      |
|o1 = {dimension of the variety => 2 } |
|      number of affine charts => 4    |
|      number of rays => 4             |
|      rank of the vector bundle => 2  |
|                                      |
|o1 : ToricVectorBundleKlyachko        |
+--------------------------------------+
|i2 : F = fan E                        |
|                                      |
|o2 = {ambient dimension => 2         }|
|      number of generating cones => 4 |
|      number of rays => 4             |
|      top dimension of the cones => 2 |
|                                      |
|o2 : Fan                              |
+--------------------------------------+
|i3 : rays F                           |
|                                      |
|o3 = {| 0  |, | 0 |, | -1 |, | 1 |}   |
|      | -1 |  | 1 |  | 3  |  | 0 |    |
|                                      |
|o3 : List                             |
+--------------------------------------+

See also
========

  * Fan (OldPolyhedra) -- the class of all fans
  * charts --  the number of maximal affine charts
  * maxCones(ToricVectorBundle) --  the
    list of maximal cones of the underlying fan

Ways to use this method:
========================

  * fan(ToricVectorBundle) --  the
    underlying fan of a toric vector bundle

filtration --  the filtration matrices of the vector bundle
***********************************************************

Synopsis
========

  * Usage:
        f = filtration E
  * Inputs:
      * E, a vector bundle on a toric variety (Klyachko's description),
  * Outputs:
      * f, a hash table (Macaulay2Doc),

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

For each ray of the fan there is a filtration matrix. If the bundle has rank
$k$ then this is a one row matrix over ZZ (Macaulay2Doc), with $k$
entries. This defines the filtration on the corresponding base matrix (see
base) such that the $j$-th filtration is generated by all columns
of the base matrix for which the entry in the same column of the filtration
matrix is less or equal to $j$.
+--------------------------------------+
|i1 : E = tangentBundle hirzebruchFan 2|
|                                      |
|o1 = {dimension of the variety => 2 } |
|      number of affine charts => 4    |
|      number of rays => 4             |
|      rank of the vector bundle => 2  |
|                                      |
|o1 : ToricVectorBundleKlyachko        |
+--------------------------------------+
|i2 : filtration E                     |
|                                      |
|o2 = HashTable{| -1 | => | -1 0 |}    |
|               | 2  |                 |
|               | 0  | => | -1 0 |     |
|               | -1 |                 |
|               | 0 | => | -1 0 |      |
|               | 1 |                  |
|               | 1 | => | -1 0 |      |
|               | 0 |                  |
|                                      |
|o2 : HashTable                        |
+--------------------------------------+

So in this example for each ray the first column of the basis appears at -1 and
the second at 0.

See also
========

  * addFiltration -- changing the filtration matrices of
    a toric vector bundle in Klyachko's description
  * base --  the basis matrices for the rays
  * isVectorBundle --  checks if the data does in fact
    define an equivariant toric vector bundle

Ways to use filtration :
========================

  * "filtration(ToricVectorBundleKlyachko)"

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

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

findWeights --  finds the possible weight vectors for the maximal cones
***********************************************************************

Synopsis
========

  * Usage:
        L = findWeights E
  * Inputs:
      * E, a vector bundle on a toric variety (Klyachko's description),
  * Outputs:
      * L, a list (Macaulay2Doc),

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

The list L contains a list for each maximal cone $\sigma$ of the underlying
fan. For each maximal cone $\sigma$ this list contains all matrices of possible
weight vectors, that induce the filtrations on the rays of this cone (modulo
permutations, but yet not all permutations). This means that for one of these
matrices $M$ multiplied with the matrix $R$ of rays of this cone (the rays are
the rows) gives the matrix of filtrations of these rays (where for each
filtration the entries may be permuted).
+-----------------------------------------------------------------------------+
|i1 : E = tangentBundle projectiveSpaceFan 3                                  |
|                                                                             |
|o1 = {dimension of the variety => 3 }                                        |
|      number of affine charts => 4                                           |
|      number of rays => 4                                                    |
|      rank of the vector bundle => 3                                         |
|                                                                             |
|o1 : ToricVectorBundleKlyachko                                               |
+-----------------------------------------------------------------------------+
|i2 : findWeights E                                                           |
|                                                                             |
|o2 = {{| 1  1 1  |, | 1  1  1 |}, {| -1 0 0  |, | -1 0  0 |}, {| -1 0  0  |, |
|       | -1 0 0  |  | -1 0  0 |    | 1  1 1  |  | 1  1  1 |    | 0  -1 0  |  |
|       | 0  0 -1 |  | 0  -1 0 |    | 0  0 -1 |  | 0  -1 0 |    | 0  0  -1 |  |
|     ------------------------------------------------------------------------|
|     | -1 0  0  |}, {| -1 0  0 |, | -1 0 0  |}}                              |
|     | 0  0  -1 |    | 0  -1 0 |  | 0  0 -1 |                                |
|     | 0  -1 0  |    | 1  1  1 |  | 1  1 1  |                                |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * filtration --  the filtration matrices of the vector
    bundle
  * existsDecomposition --  checks if a list of
    matrices of weight vectors for each maximal cone admits a decomposition
  * isVectorBundle --  checks if the data does in fact
    define an equivariant toric vector bundle

Ways to use findWeights :
=========================

  * "findWeights(ToricVectorBundleKlyachko)"

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

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

HH^ZZ ToricVectorBundle --  the i-th cohomology group of a toric vector bundle
******************************************************************************

Synopsis
========

  * Function: cohomology (Macaulay2Doc),
  * Usage:
        c = HH^i E
  * Inputs:
      * i, an integer (Macaulay2Doc),
      * T, an instance of the type ToricVectorBundle,
  * Optional inputs (Macaulay2Doc),:
      * Degree (missing documentation) => ..., default value 0, null
  * Outputs:
      * c, a module (Macaulay2Doc),

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

Computes the $i$-th cohomology group of the toric vector bundle $E$. The output
is the $i$-th cohomology group as a multigraded module. For this, it computes
the set of all degrees that can give non-zero cohomology (see deltaE).
This set is finite if the underlying toric variety is complete. If
the toric variety is not complete then an error is returned.

The computation of the cohomology groups for a toric vector bundle given in
terms of Kaneyama is done by the usual Cech cohomology complex, again
separately for every degree $u \in{} M$.

If the option Degree => 1 is used then it displays the number of degrees for
which it computes the cohomology. $i$ must be between $0$ and the dimension of
the underlying toric variety.
+-----------------------------------------------------------------------------+
|i1 : E = tangentBundle(hirzebruchFan 3,"Type" => "Kaneyama")                 |
|                                                                             |
|o1 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o1 : ToricVectorBundleKaneyama                                               |
+-----------------------------------------------------------------------------+
|i2 : HH^0 E                                                                  |
|                                                                             |
|           8                                                                 |
|o2 = (QQ[])                                                                  |
|                                                                             |
|o2 : QQ[]-module, free, degrees {{-1, 0}, 2:{0, 0}, {1, 0}, {0, 1}, {1, 1},  |
|-----------------------------------------------------------------------------|
|{2, 1}, {3, 1}}                                                              |
+-----------------------------------------------------------------------------+
|i3 : HH^0 (E,Degree => 1)                                                    |
|Number of degrees to calculate: 11                                           |
|...........                                                                  |
|           8                                                                 |
|o3 = (QQ[])                                                                  |
|                                                                             |
|o3 : QQ[]-module, free, degrees {{-1, 0}, 2:{0, 0}, {1, 0}, {0, 1}, {1, 1},  |
|-----------------------------------------------------------------------------|
|{2, 1}, {3, 1}}                                                              |
+-----------------------------------------------------------------------------+

"In case the toric vector bundle $E$ is given in Klyachko's description, there
is a special exact sequence of finite dimensional vector spaces for every
weight $u \in{} M$ whose cohomology groups in degree $i$ are isomorphic to
$H^i(X,E)$. This exact sequence can be found in the Klyachko's paper listed on
the main page of the documentation."

If the option Degree => 1 is used then it displays the number of degrees for
which it computes the cohomology. $i$ must be between $0$ and the dimension of
the underlying toric variety.
+-----------------------------------------------------------------------------+
|i4 : E = tangentBundle hirzebruchFan 3                                       |
|                                                                             |
|o4 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      number of rays => 4                                                    |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o4 : ToricVectorBundleKlyachko                                               |
+-----------------------------------------------------------------------------+
|i5 : HH^0 E                                                                  |
|                                                                             |
|           8                                                                 |
|o5 = (QQ[])                                                                  |
|                                                                             |
|o5 : QQ[]-module, free, degrees {{-1, 0}, 2:{0, 0}, {1, 0}, {0, 1}, {1, 1},  |
|-----------------------------------------------------------------------------|
|{2, 1}, {3, 1}}                                                              |
+-----------------------------------------------------------------------------+
|i6 : HH^0 (E,Degree => 1)                                                    |
|Number of degrees to calculate: 11                                           |
|...........                                                                  |
|           8                                                                 |
|o6 = (QQ[])                                                                  |
|                                                                             |
|o6 : QQ[]-module, free, degrees {{-1, 0}, 2:{0, 0}, {1, 0}, {0, 1}, {1, 1},  |
|-----------------------------------------------------------------------------|
|{2, 1}, {3, 1}}                                                              |
+-----------------------------------------------------------------------------+

See also
========

  * ring(ToricVectorBundle) --  the graded
    ring of the bundle
  * deltaE --  the polytope of possible degrees that give non
    zero cohomology
  * HH^ZZ(ToricVectorBundle,Matrix)
    --  the i-th cohomology of a toric
    vector bundle in a given degree
  * HH^ZZ(ToricVectorBundle,List),
    --  the i-th cohomology of a toric vector bundle for a given list of
    degrees
  * hh^ZZ ToricVectorBundle --  the rank of the
    i-th cohomology group of a toric vector bundle
  * eulerChi --  the Euler characteristic of a toric vector
    bundle

Ways to use this method:
========================

  * HH^ZZ ToricVectorBundle --  the i-th
    cohomology group of a toric vector bundle

hh^ZZ ToricVectorBundle --  the rank of the i-th cohomology group of a toric vector bundle
******************************************************************************************

Synopsis
========

  * Scripted functor: hh (Macaulay2Doc),
  * Usage:
        d = hh^i E
        d = hh^i (E,u)
  * Inputs:
      * i, an integer (Macaulay2Doc),
      * E, an instance of the type ToricVectorBundle,
        and an optional u, a matrix (Macaulay2Doc), over ZZ (Macaulay2Doc),
        giving a point in the lattice of the fan
  * Outputs:
      * d, an integer (Macaulay2Doc),

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

hh^i computes the rank of the $i$-th cohomology group. If no further argument
is given then it returns the rank of the complete cohomology group. For this it
computes the set of all degrees that can give non-zero cohomology (see
deltaE). This set is finite if the underlying toric variety is
complete. If the toric variety is not complete, then an error is returned.

If in addition a one column matrix $u$ over ZZ (Macaulay2Doc), is
given it returns the rank of the degree $u$ part of the cohomology group. For
this the variety need not be complete.
+--------------------------------------+
|i1 : E = tangentBundle hirzebruchFan 2|
|                                      |
|o1 = {dimension of the variety => 2 } |
|      number of affine charts => 4    |
|      number of rays => 4             |
|      rank of the vector bundle => 2  |
|                                      |
|o1 : ToricVectorBundleKlyachko        |
+--------------------------------------+
|i2 : u = matrix{{0},{0}}              |
|                                      |
|o2 = 0                                |
|                                      |
|              2        1              |
|o2 : Matrix ZZ  <--- ZZ               |
+--------------------------------------+
|i3 : hh^0 (E,u)                       |
|                                      |
|o3 = 2                                |
+--------------------------------------+
|i4 : hh^0 E                           |
|                                      |
|o4 = 7                                |
+--------------------------------------+

See also
========

  * HH^ZZ ToricVectorBundle --  the i-th
    cohomology group of a toric vector bundle
  * HH^ZZ(ToricVectorBundle,Matrix)
    --  the i-th cohomology of a toric
    vector bundle in a given degree
  * HH^ZZ(ToricVectorBundle,List),
    --  the i-th cohomology of a toric vector bundle for a given list of
    degrees
  * deltaE --  the polytope of possible degrees that give non
    zero cohomology

Ways to use this method:
========================

  * hh^ZZ ToricVectorBundle --  the rank of the
    i-th cohomology group of a toric vector bundle

HH^ZZ(ToricVectorBundle,List) --  the i-th cohomology of a toric vector bundle for a given list of degrees
**********************************************************************************************************

Synopsis
========

  * Function: cohomology (Macaulay2Doc),
  * Usage:
        c = HH_i^E L
  * Inputs:
      * i, an integer (Macaulay2Doc),
      * E, an instance of the type ToricVectorBundle,
      * L, a list (Macaulay2Doc),  containing weights of the form,
        one column matrix over ZZ (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Degree (missing documentation) => ..., default value 0, null
  * Outputs:
      * c, a list (Macaulay2Doc),

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

"Computes the $i$-th cohomology of the toric vector bundle $E$ for a given list
of degrees. For this $i$ must be between $0$ and the rank of the vector bundle.
The entries of the list "L must be one column matrices each defining a point in
the lattice of the fan over which $E$ is defined
+----------------------------------------------+
|i1 : E = tangentBundle hirzebruchFan 3        |
|                                              |
|o1 = {dimension of the variety => 2 }         |
|      number of affine charts => 4            |
|      number of rays => 4                     |
|      rank of the vector bundle => 2          |
|                                              |
|o1 : ToricVectorBundleKlyachko                |
+----------------------------------------------+
|i2 : HH_0^E {matrix{{1},{0}},matrix{{-1},{0}}}|
|                                              |
|            1        1                        |
|o2 = {(QQ[]) , (QQ[]) }                       |
|                                              |
|o2 : List                                     |
+----------------------------------------------+

See also
========

  * ring(ToricVectorBundle) --  the graded
    ring of the bundle
  * deltaE --  the polytope of possible degrees that give non
    zero cohomology
  * HH^ZZ ToricVectorBundle --  the i-th
    cohomology group of a toric vector bundle
  * HH^ZZ(ToricVectorBundle,Matrix)
    --  the i-th cohomology of a toric
    vector bundle in a given degree
  * hh^ZZ ToricVectorBundle --  the rank of the
    i-th cohomology group of a toric vector bundle
  * eulerChi --  the Euler characteristic of a toric vector
    bundle

Ways to use this method:
========================

  * HH^ZZ(ToricVectorBundle,List),
    --  the i-th cohomology of a toric vector bundle for a given list of
    degrees

HH^ZZ(ToricVectorBundle,Matrix) --  the i-th cohomology of a toric vector bundle in a given degree
**************************************************************************************************

Synopsis
========

  * Function: cohomology (Macaulay2Doc),
  * Usage:
        c = HH_i^E u
  * Inputs:
      * i, an integer (Macaulay2Doc),
      * E, an instance of the type ToricVectorBundle,
      * u, a matrix (Macaulay2Doc), over ZZ (Macaulay2Doc),
        with just one column, giving a weight in the lattice
  * Optional inputs (Macaulay2Doc),:
      * Degree (missing documentation) => ..., default value 0, null
  * Outputs:
      * c, a module (Macaulay2Doc),

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

"Computes the $i$-th cohomology group of the toric vector bundle $E$ of degree
$u$ where $u$ must be a one-column matrix giving a point in the lattice of the
fan over which $E$ is defined and $i$ must be between $0$ and the dimension of
the underlying toric variety."
+----------------------------------------+
|i1 : E = tangentBundle hirzebruchFan 3  |
|                                        |
|o1 = {dimension of the variety => 2 }   |
|      number of affine charts => 4      |
|      number of rays => 4               |
|      rank of the vector bundle => 2    |
|                                        |
|o1 : ToricVectorBundleKlyachko          |
+----------------------------------------+
|i2 : HH^0 (E,matrix{{1},{0}})           |
|                                        |
|           1                            |
|o2 = (QQ[])                             |
|                                        |
|o2 : QQ[]-module, free, degrees {{1, 0}}|
+----------------------------------------+

See also
========

  * ring(ToricVectorBundle) --  the graded
    ring of the bundle
  * deltaE --  the polytope of possible degrees that give non
    zero cohomology
  * HH^ZZ ToricVectorBundle --  the i-th
    cohomology group of a toric vector bundle
  * HH^ZZ(ToricVectorBundle,List),
    --  the i-th cohomology of a toric vector bundle for a given list of
    degrees
  * hh^ZZ ToricVectorBundle --  the rank of the
    i-th cohomology group of a toric vector bundle
  * eulerChi --  the Euler characteristic of a toric vector
    bundle

Ways to use this method:
========================

  * HH^ZZ(ToricVectorBundle,Matrix)
    --  the i-th cohomology of a toric
    vector bundle in a given degree

hirzebruchFan -- the fan of the n-th Hirzebruch surface
*******************************************************

Synopsis
========

  * Usage:
        F = hirzebruchFan n
  * Inputs:
      * n, an integer (Macaulay2Doc), positive
  * Outputs:
      * F, an instance of the type Fan (OldPolyhedra),

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

Generates the fan of the $n$-th Hirzebruch surface.
+--------------------------------------+
|i1 : F = hirzebruchFan 3              |
|                                      |
|o1 = {ambient dimension => 2         }|
|      number of generating cones => 4 |
|      number of rays => 4             |
|      top dimension of the cones => 2 |
|                                      |
|o1 : Fan                              |
+--------------------------------------+
|i2 : rays F                           |
|                                      |
|o2 = {| 0  |, | 0 |, | -1 |, | 1 |}   |
|      | -1 |  | 1 |  | 3  |  | 0 |    |
|                                      |
|o2 : List                             |
+--------------------------------------+

See also
========

  * Fan (OldPolyhedra) -- the class of all fans
  * hirzebruch (OldPolyhedra) -- computes the fan of the r-th
    Hirzebruch surface
  * pp1ProductFan -- the fan of n products of PP^1
  * projectiveSpaceFan -- the fan of projective n
    space

Ways to use hirzebruchFan :
===========================

  * "hirzebruchFan(ZZ)"

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

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

image(ToricVectorBundleKlyachko,Matrix) --  the image of a vector bundle under a morphism
*****************************************************************************************

Synopsis
========

  * Function: image (Macaulay2Doc),
  * Usage:
        E1 = image(E,M)
  * Inputs:
      * E, a vector bundle on a toric variety (Klyachko's description),
      * M, a matrix (Macaulay2Doc), over ZZ (Macaulay2Doc),
        or QQ (Macaulay2Doc),
  * Outputs:
      * E1, a vector bundle on a toric variety (Klyachko's description),

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

M must be a matrix over ZZ (Macaulay2Doc), or QQ (Macaulay2Doc),
where the source space is the space of the bundle, i.e., the
matrix must have $k$ columns if the bundle has rank $k$. Then the new bundle is
given on each ray $\rho$ by the following filtration of image$(E,M)^\rho :=
M(E^\rho)$ :

image$(E,M)^\rho(i) := M(E^\rho(i))$.
+---------------------------------------------------+
|i1 : E = tangentBundle hirzebruchFan 2             |
|                                                   |
|o1 = {dimension of the variety => 2 }              |
|      number of affine charts => 4                 |
|      number of rays => 4                          |
|      rank of the vector bundle => 2               |
|                                                   |
|o1 : ToricVectorBundleKlyachko                     |
+---------------------------------------------------+
|i2 : E = E ** E                                    |
|                                                   |
|o2 = {dimension of the variety => 2 }              |
|      number of affine charts => 4                 |
|      number of rays => 4                          |
|      rank of the vector bundle => 4               |
|                                                   |
|o2 : ToricVectorBundleKlyachko                     |
+---------------------------------------------------+
|i3 : M = matrix {{1,0,1,0},{0,1,0,1/1}}            |
|                                                   |
|o3 = | 1 0 1 0 |                                   |
|     | 0 1 0 1 |                                   |
|                                                   |
|              2        4                           |
|o3 : Matrix QQ  <--- QQ                            |
+---------------------------------------------------+
|i4 : E1 = image(E,M)                               |
|                                                   |
|o4 = {dimension of the variety => 2 }              |
|      number of affine charts => 4                 |
|      number of rays => 4                          |
|      rank of the vector bundle => 2               |
|                                                   |
|o4 : ToricVectorBundleKlyachko                     |
+---------------------------------------------------+
|i5 : details E1                                    |
|                                                   |
|o5 = HashTable{| -1 | => (| -1/2 1/2 |, | -2 -1 |)}|
|               | 2  |     | 1    0   |             |
|               | 0  | => (| 0 1 |, | -2 -1 |)      |
|               | -1 |     | 1 0 |                  |
|               | 0 | => (| 0 1 |, | -2 -1 |)       |
|               | 1 |     | 1 0 |                   |
|               | 1 | => (| 1 0 |, | -2 -1 |)       |
|               | 0 |     | 0 1 |                   |
|                                                   |
|o5 : HashTable                                     |
+---------------------------------------------------+

See also
========

  * cokernel(ToricVectorBundleKlyachko,Matrix)
    --  the cokernel of a
    morphism to a vector bundle
  * kernel(ToricVectorBundleKlyachko,Matrix)
    --  the kernel of a
    morphism to a vector bundle

Ways to use this method:
========================

  * image(ToricVectorBundleKlyachko,Matrix)
    --  the image of a vector
    bundle under a morphism

isGeneral --  checks whether a toric vector bundle is general
*************************************************************

Synopsis
========

  * Usage:
        b = isGeneral E
  * Inputs:
      * E, a vector bundle on a toric variety (Klyachko's description),
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), whether E is general

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

"A toric vector bundle in Klyachko's description is general if for every
maximal cone $\Sigma$ in the fan the following condition holds: Let
$\rho_1,...,\rho_l$ be the rays of $\sigma$. Then for every choice of
filtration steps $i_1,...,i_l$ for each ray, i.e., choose an integer for each
ray where the filtration enlarges, the equation"

codim $(\cap E^{\rho_j} ( i_j )) = min \{ \sum ($codim $E^{\rho_j} ( i_j
)),rank E \}$

holds.
+----------------------------------------+
|i1 : E = cotangentBundle hirzebruchFan 2|
|                                        |
|o1 = {dimension of the variety => 2 }   |
|      number of affine charts => 4      |
|      number of rays => 4               |
|      rank of the vector bundle => 2    |
|                                        |
|o1 : ToricVectorBundleKlyachko          |
+----------------------------------------+
|i2 : isGeneral E                        |
|                                        |
|o2 = true                               |
+----------------------------------------+

See also
========

  * filtration --  the filtration matrices of the vector
    bundle
  * base --  the basis matrices for the rays
  * randomDeformation --  a random deformation of a
    given toric vector bundle

Ways to use isGeneral :
=======================

  * "isGeneral(ToricVectorBundleKlyachko)"

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

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

isomorphism --  the isomorphism if the two bundles are isomorphic
*****************************************************************

Synopsis
========

  * Usage:
        M = isomorphism(E,F)
  * Inputs:
      * E, a vector bundle on a toric variety (Klyachko's description),
      * F, a vector bundle on a toric variety (Klyachko's description),
  * Outputs:
      * M, a matrix (Macaulay2Doc), over the ring over which the
        two bundles are defined

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

Two equivariant vector bundles in Klyachko's description are isomorphic if
there exists a simultaneous isomorphism for the filtered vector spaces of all
rays. If the two bundles are isomorphic (see areIsomorphic)
this function returns the isomorphism. For this, the two
bundles must be defined over the same fan.
+---------------------------------------------+
|i1 : HF = hirzebruchFan 2                    |
|                                             |
|o1 = {ambient dimension => 2         }       |
|      number of generating cones => 4        |
|      number of rays => 4                    |
|      top dimension of the cones => 2        |
|                                             |
|o1 : Fan                                     |
+---------------------------------------------+
|i2 : E = exteriorPower(2, cotangentBundle HF)|
|                                             |
|o2 = {dimension of the variety => 2 }        |
|      number of affine charts => 4           |
|      number of rays => 4                    |
|      rank of the vector bundle => 1         |
|                                             |
|o2 : ToricVectorBundleKlyachko               |
+---------------------------------------------+
|i3 : F = weilToCartier({-1,-1,-1,-1},HF)     |
|                                             |
|o3 = {dimension of the variety => 2 }        |
|      number of affine charts => 4           |
|      number of rays => 4                    |
|      rank of the vector bundle => 1         |
|                                             |
|o3 : ToricVectorBundleKlyachko               |
+---------------------------------------------+
|i4 : M = isomorphism(E,F)                    |
|                                             |
|o4 = | 1 |                                   |
|                                             |
|              1        1                     |
|o4 : Matrix QQ  <--- QQ                      |
+---------------------------------------------+

See also
========

  * areIsomorphic -- checks if two vector bundles are
    isomorphic
  * base --  the basis matrices for the rays
  * filtration --  the filtration matrices of the vector
    bundle
  * details --  the details of a toric vector bundle

Ways to use isomorphism :
=========================

  * "isomorphism(ToricVectorBundleKlyachko,ToricVectorBundleKlyachko)"

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

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

isVectorBundle --  checks if the data does in fact define an equivariant toric vector bundle
********************************************************************************************

Synopsis
========

  * Usage:
        b = isVectorBundle E
  * Inputs:
      * E, an instance of the type ToricVectorBundle,
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), whether E defines a
        toric vector bundle

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

If E is in Klyachko's description then the data in E defines an equivariant
toric vector on the toric variety if and only if for each maximal cone exists a
decomposition into torus eigenspaces of the bundle. See Sam Payne's (see
http://math.stanford.edu/~sampayne/ ) Moduli of toric vector bundles,
Compositio Math. 144, 2008. Section 2.3. This uses the two functions
findWeights, and existsDecomposition.
+-----------------------------------------------------------------------------+
|i1 : E = toricVectorBundle(2,pp1ProductFan 2)                                |
|                                                                             |
|o1 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      number of rays => 4                                                    |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o1 : ToricVectorBundleKlyachko                                               |
+-----------------------------------------------------------------------------+
|i2 : E = addBase(E,{matrix{{1,2},{3,1}},matrix{{-1,0},{3,1}},matrix{{1,2},{-3|
|                                                                             |
|o2 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      number of rays => 4                                                    |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o2 : ToricVectorBundleKlyachko                                               |
|-----------------------------------------------------------------------------|
|,-1}},matrix{{-1,0},{-3,-1}}})                                               |
+-----------------------------------------------------------------------------+
|i3 : isVectorBundle E                                                        |
|                                                                             |
|o3 = true                                                                    |
+-----------------------------------------------------------------------------+
|i4 : F = toricVectorBundle(1,normalFan crossPolytope 3)                      |
|                                                                             |
|o4 = {dimension of the variety => 3 }                                        |
|      number of affine charts => 6                                           |
|      number of rays => 8                                                    |
|      rank of the vector bundle => 1                                         |
|                                                                             |
|o4 : ToricVectorBundleKlyachko                                               |
+-----------------------------------------------------------------------------+
|i5 : F = addFiltration(F,apply({2,1,1,2,2,1,1,2}, i -> matrix {{i}}))        |
|                                                                             |
|o5 = {dimension of the variety => 3 }                                        |
|      number of affine charts => 6                                           |
|      number of rays => 8                                                    |
|      rank of the vector bundle => 1                                         |
|                                                                             |
|o5 : ToricVectorBundleKlyachko                                               |
+-----------------------------------------------------------------------------+
|i6 : isVectorBundle F                                                        |
|                                                                             |
|o6 = false                                                                   |
+-----------------------------------------------------------------------------+

If E is in Kaneyama's description then data in E defines an equivariant toric
vector bundle on the toric variety if and only if it satisfies the regularity
and the cocycle condition (See cocycleCheck, and
regCheck).
+-----------------------------------------------------------------------------+
|i7 : E = toricVectorBundle(2,pp1ProductFan 2,"Type" => "Kaneyama")           |
|                                                                             |
|o7 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o7 : ToricVectorBundleKaneyama                                               |
+-----------------------------------------------------------------------------+
|i8 : isVectorBundle E                                                        |
|                                                                             |
|o8 = true                                                                    |
+-----------------------------------------------------------------------------+
|i9 : E = addBaseChange(E,{matrix{{1,2},{3,1}},matrix{{-1,0},{3,1}},matrix{{1,|
|                                                                             |
|o9 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o9 : ToricVectorBundleKaneyama                                               |
|-----------------------------------------------------------------------------|
|2},{-3,-1}},matrix{{-1,0},{-3,-1}}})                                         |
+-----------------------------------------------------------------------------+
|i10 : isVectorBundle E                                                       |
|                                                                             |
|o10 = false                                                                  |
+-----------------------------------------------------------------------------+

See also
========

  * findWeights --  finds the possible weight vectors for
    the maximal cones
  * existsDecomposition --  checks if a list of
    matrices of weight vectors for each maximal cone admits a decomposition
  * addBase -- changing the basis matrices of a toric vector
    bundle in Klyachko's description
  * addFiltration -- changing the filtration matrices of
    a toric vector bundle in Klyachko's description
  * cocycleCheck --  checks if a toric vector bundle
    fulfills the cocycle condition
  * regCheck --  checking the regularity condition for a toric
    vector bundle
  * addBaseChange -- changing the transition matrices of
    a toric vector bundle
  * addDegrees -- changing the degrees of a toric vector
    bundle
  * details --  the details of a toric vector bundle

Ways to use isVectorBundle :
============================

  * "isVectorBundle(ToricVectorBundle)"

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

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

kernel(ToricVectorBundleKlyachko,Matrix) --  the kernel of a morphism to a vector bundle
****************************************************************************************

Synopsis
========

  * Function: kernel (Macaulay2Doc),
  * Usage:
        E1 = ker(E,M)
  * Inputs:
      * E, a vector bundle on a toric variety (Klyachko's description),
      * M, a matrix (Macaulay2Doc), over ZZ (Macaulay2Doc),
        or QQ (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * SubringLimit (Macaulay2Doc),
        => ..., default value infinity, null
  * Outputs:
      * E1, a vector bundle on a toric variety (Klyachko's description),

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

M must be a matrix over ZZ (Macaulay2Doc), or QQ (Macaulay2Doc),
where the source space is the space of the bundle, i.e., the
matrix must have $k$ columns if the bundle has rank $k$. Then the new bundle is
given on each ray $\rho$ by the following filtration of ker$(E,M)^\rho := $
ker$(M) \cap (E^\rho)$ :

ker$(E,M)^\rho(i) := $ ker$(M) \cap E^\rho(i)$.
+--------------------------------------------------+
|i1 : E = tangentBundle hirzebruchFan 2            |
|                                                  |
|o1 = {dimension of the variety => 2 }             |
|      number of affine charts => 4                |
|      number of rays => 4                         |
|      rank of the vector bundle => 2              |
|                                                  |
|o1 : ToricVectorBundleKlyachko                    |
+--------------------------------------------------+
|i2 : E = E ** E                                   |
|                                                  |
|o2 = {dimension of the variety => 2 }             |
|      number of affine charts => 4                |
|      number of rays => 4                         |
|      rank of the vector bundle => 4              |
|                                                  |
|o2 : ToricVectorBundleKlyachko                    |
+--------------------------------------------------+
|i3 : M = matrix {{1,0,1,0},{0,1,0,1/1}}           |
|                                                  |
|o3 = | 1 0 1 0 |                                  |
|     | 0 1 0 1 |                                  |
|                                                  |
|              2        4                          |
|o3 : Matrix QQ  <--- QQ                           |
+--------------------------------------------------+
|i4 : E1 = ker(E,M)                                |
|                                                  |
|o4 = {dimension of the variety => 2 }             |
|      number of affine charts => 4                |
|      number of rays => 4                         |
|      rank of the vector bundle => 2              |
|                                                  |
|o4 : ToricVectorBundleKlyachko                    |
+--------------------------------------------------+
|i5 : details E1                                   |
|                                                  |
|o5 = HashTable{| -1 | => (| -1/2 1/2 |, | -1 0 |)}|
|               | 2  |     | 1    0   |            |
|               | 0  | => (| 0 1 |, | -1 0 |)      |
|               | -1 |     | 1 0 |                 |
|               | 0 | => (| 0 1 |, | -1 0 |)       |
|               | 1 |     | 1 0 |                  |
|               | 1 | => (| 1 0 |, | -1 0 |)       |
|               | 0 |     | 0 1 |                  |
|                                                  |
|o5 : HashTable                                    |
+--------------------------------------------------+

See also
========

  * cokernel(ToricVectorBundleKlyachko,Matrix)
    --  the cokernel of a
    morphism to a vector bundle
  * image(ToricVectorBundleKlyachko,Matrix)
    --  the image of a vector
    bundle under a morphism

Ways to use this method:
========================

  * kernel(ToricVectorBundleKlyachko,Matrix)
    --  the kernel of a
    morphism to a vector bundle

maxCones(ToricVectorBundle) --  the list of maximal cones of the underlying fan
*******************************************************************************

Synopsis
========

  * Function: maxCones (OldPolyhedra),
  * Usage:
        L = maxCones E
  * Inputs:
      * E, an instance of the type ToricVectorBundle,
  * Outputs:
      * L, a list (Macaulay2Doc),  of cones

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

Returns the list of maximal cones of the underlying fan. These are the cones
that generate the fan, i.e., are not a face of another. See Fan (OldPolyhedra),
see maxCones (OldPolyhedra), and Cone (OldPolyhedra).
+-----------------------------------------------------------------------------+
|i1 : E = tangentBundle pp1ProductFan 2                                       |
|                                                                             |
|o1 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      number of rays => 4                                                    |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o1 : ToricVectorBundleKlyachko                                               |
+-----------------------------------------------------------------------------+
|i2 : L = maxCones E                                                          |
|                                                                             |
|o2 = {{ambient dimension => 2           }, {ambient dimension => 2           |
|       dimension of lineality space => 0    dimension of lineality space =>  |
|       dimension of the cone => 2           dimension of the cone => 2       |
|       number of facets => 2                number of facets => 2            |
|       number of rays => 2                  number of rays => 2              |
|     ------------------------------------------------------------------------|
|      }, {ambient dimension => 2           }, {ambient dimension => 2        |
|     0    dimension of lineality space => 0    dimension of lineality space  |
|          dimension of the cone => 2           dimension of the cone => 2    |
|          number of facets => 2                number of facets => 2         |
|          number of rays => 2                  number of rays => 2           |
|     ------------------------------------------------------------------------|
|         }}                                                                  |
|     => 0                                                                    |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : apply(L,rays)                                                           |
|                                                                             |
|o3 = {| 1 0 |, | 1 0  |, | -1 0 |, | -1 0  |}                                |
|      | 0 1 |  | 0 -1 |  | 0  1 |  | 0  -1 |                                 |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i4 : E = tangentBundle(pp1ProductFan 2,"Type" => "Kaneyama")                 |
|                                                                             |
|o4 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o4 : ToricVectorBundleKaneyama                                               |
+-----------------------------------------------------------------------------+
|i5 : L = maxCones E                                                          |
|                                                                             |
|o5 = {{ambient dimension => 2           }, {ambient dimension => 2           |
|       dimension of lineality space => 0    dimension of lineality space =>  |
|       dimension of the cone => 2           dimension of the cone => 2       |
|       number of facets => 2                number of facets => 2            |
|       number of rays => 2                  number of rays => 2              |
|     ------------------------------------------------------------------------|
|      }, {ambient dimension => 2           }, {ambient dimension => 2        |
|     0    dimension of lineality space => 0    dimension of lineality space  |
|          dimension of the cone => 2           dimension of the cone => 2    |
|          number of facets => 2                number of facets => 2         |
|          number of rays => 2                  number of rays => 2           |
|     ------------------------------------------------------------------------|
|         }}                                                                  |
|     => 0                                                                    |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : apply(L,rays)                                                           |
|                                                                             |
|o6 = {| 1 0 |, | 1 0  |, | -1 0 |, | -1 0  |}                                |
|      | 0 1 |  | 0 -1 |  | 0  1 |  | 0  -1 |                                 |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * Fan (OldPolyhedra) -- the class of all fans
  * maxCones (OldPolyhedra) -- displays the generating Cones of
    a Fan
  * Cone (OldPolyhedra) -- the class of all rational convex
    polyhedral cones
  * charts --  the number of maximal affine charts
  * fan(ToricVectorBundle) --  the
    underlying fan of a toric vector bundle
  * rays(ToricVectorBundle) --  the rays of
    the underlying fan

Ways to use this method:
========================

  * maxCones(ToricVectorBundle) --  the
    list of maximal cones of the underlying fan

net(ToricVectorBundleKaneyama) -- displays characteristics of a toric vector bundle
***********************************************************************************

Synopsis
========

  * Function: net (Macaulay2Doc),
  * Usage:
        net E
  * Inputs:
      * E, a vector bundle on a toric variety (Kaneyama's description),
  * Outputs:
      * a net (Macaulay2Doc),

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

Displays an overview of the properties of a toric vector bundle, the dimension
of the variety, the number of affine charts, and the rank of the vector bundle.
+-------------------------------------------------------------+
|i1 : E = tangentBundle(hirzebruchFan 3,"Type" => "Kaneyama");|
+-------------------------------------------------------------+
|i2 : net E                                                   |
|                                                             |
|o2 = {dimension of the variety => 2 }                        |
|      number of affine charts => 4                           |
|      rank of the vector bundle => 2                         |
+-------------------------------------------------------------+

See also
========

  * net(ToricVectorBundleKlyachko),
    -- displays characteristics of a toric vector bundle in Klyachko's
    description
  * details --  the details of a toric vector bundle

Ways to use this method:
========================

  * net(ToricVectorBundleKaneyama),
    -- displays characteristics of a toric vector bundle

net(ToricVectorBundleKlyachko) -- displays characteristics of a toric vector bundle in Klyachko's description
*************************************************************************************************************

Synopsis
========

  * Function: net (Macaulay2Doc),
  * Usage:
        net E
  * Inputs:
      * E, a vector bundle on a toric variety (Klyachko's description),
  * Outputs:
      * a net (Macaulay2Doc),

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

Displays an overview of the properties of a toric vector bundle, the dimension
of the variety, the number of affine charts, the number of rays of the fan, and
the rank of the vector bundle.
+---------------------------------------+
|i1 : E = tangentBundle hirzebruchFan 3;|
+---------------------------------------+
|i2 : net E                             |
|                                       |
|o2 = {dimension of the variety => 2 }  |
|      number of affine charts => 4     |
|      number of rays => 4              |
|      rank of the vector bundle => 2   |
+---------------------------------------+

See also
========

  * net(ToricVectorBundleKaneyama),
    -- displays characteristics of a toric vector bundle
  * details --  the details of a toric vector bundle

Ways to use this method:
========================

  * net(ToricVectorBundleKlyachko),
    -- displays characteristics of a toric vector bundle in Klyachko's
    description

pp1ProductFan -- the fan of n products of PP^1
**********************************************

Synopsis
========

  * Usage:
        F = pp1ProductFan n
  * Inputs:
      * n, an integer (Macaulay2Doc), strictly positive
  * Outputs:
      * F, an instance of the type Fan (OldPolyhedra),

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

Generates the fan of the product of $n$ projective one-spaces. This is the same
as the normal fan of the $n$ dimensional hypercube.
+---------------------------------------------+
|i1 : F = pp1ProductFan 2                     |
|                                             |
|o1 = {ambient dimension => 2         }       |
|      number of generating cones => 4        |
|      number of rays => 4                    |
|      top dimension of the cones => 2        |
|                                             |
|o1 : Fan                                     |
+---------------------------------------------+
|i2 : apply(maxCones F, rays)                 |
|                                             |
|o2 = {| -1 0  |, | 1 0  |, | 1 0 |, | -1 0 |}|
|      | 0  -1 |  | 0 -1 |  | 0 1 |  | 0  1 | |
|                                             |
|o2 : List                                    |
+---------------------------------------------+

See also
========

  * Fan (OldPolyhedra) -- the class of all fans
  * hirzebruchFan -- the fan of the n-th Hirzebruch
    surface
  * projectiveSpaceFan -- the fan of projective n
    space

Ways to use pp1ProductFan :
===========================

  * "pp1ProductFan(ZZ)"

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

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

projectiveSpaceFan -- the fan of projective n space
***************************************************

Synopsis
========

  * Usage:
        F = projectiveSpaceFan n
  * Inputs:
      * n, an integer (Macaulay2Doc), strictly positive
  * Outputs:
      * F, an instance of the type Fan (OldPolyhedra),

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

Generates the fan of projective $n$-space.
+--------------------------------------+
|i1 : F = projectiveSpaceFan 2         |
|                                      |
|o1 = {ambient dimension => 2         }|
|      number of generating cones => 3 |
|      number of rays => 3             |
|      top dimension of the cones => 2 |
|                                      |
|o1 : Fan                              |
+--------------------------------------+
|i2 : apply(maxCones F, rays)          |
|                                      |
|o2 = {| 1 0 |, | -1 0 |, | 1 -1 |}    |
|      | 0 1 |  | -1 1 |  | 0 -1 |     |
|                                      |
|o2 : List                             |
+--------------------------------------+

See also
========

  * Fan (OldPolyhedra) -- the class of all fans
  * hirzebruchFan -- the fan of the n-th Hirzebruch
    surface
  * pp1ProductFan -- the fan of n products of PP^1

Ways to use projectiveSpaceFan :
================================

  * "projectiveSpaceFan(ZZ)"

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

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

randomDeformation --  a random deformation of a given toric vector bundle
*************************************************************************

Synopsis
========

  * Usage:
        E1 = randomDeformation(E,h)
        E1 = randomDeformation(E,l,h)
  * Inputs:
      * E, a vector bundle on a toric variety (Klyachko's description),
      * l, an integer (Macaulay2Doc), less than h
      * h, an integer (Macaulay2Doc),
  * Outputs:
      * E1, a vector bundle on a toric variety (Klyachko's description),

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

"For a bundle of rank $k$ the function "randomDeformation" replaces each base
matrix by a random $k$ by $k$ matrix with entries between $l$ and $h$. For this
$h$ must be greater than $l$. If $l$ is not given then the random entries are
between $0$ and $h$ and then $h$ must be strictly positive."
+----------------------------------------------+
|i1 : E = tangentBundle pp1ProductFan 2        |
|                                              |
|o1 = {dimension of the variety => 2 }         |
|      number of affine charts => 4            |
|      number of rays => 4                     |
|      rank of the vector bundle => 2          |
|                                              |
|o1 : ToricVectorBundleKlyachko                |
+----------------------------------------------+
|i2 : details E                                |
|                                              |
|o2 = HashTable{| -1 | => (| -1 0 |, | -1 0 |)}|
|               | 0  |     | 0  1 |            |
|               | 0  | => (| 0  1 |, | -1 0 |) |
|               | -1 |     | -1 0 |            |
|               | 0 | => (| 0 1 |, | -1 0 |)   |
|               | 1 |     | 1 0 |              |
|               | 1 | => (| 1 0 |, | -1 0 |)   |
|               | 0 |     | 0 1 |              |
|                                              |
|o2 : HashTable                                |
+----------------------------------------------+
|i3 : E1 = randomDeformation(E,-2,6)           |
|                                              |
|o3 = {dimension of the variety => 2 }         |
|      number of affine charts => 4            |
|      number of rays => 4                     |
|      rank of the vector bundle => 2          |
|                                              |
|o3 : ToricVectorBundleKlyachko                |
+----------------------------------------------+
|i4 : details E1                               |
|                                              |
|o4 = HashTable{| -1 | => (| 6 1 |, | -1 0 |) }|
|               | 0  |     | 1 5 |             |
|               | 0  | => (| 6 -1 |, | -1 0 |) |
|               | -1 |     | 1 5  |            |
|               | 0 | => (| 6 3 |, | -1 0 |)   |
|               | 1 |     | 0 1 |              |
|               | 1 | => (| 6 6 |, | -1 0 |)   |
|               | 0 |     | 3 5 |              |
|                                              |
|o4 : HashTable                                |
+----------------------------------------------+

See also
========

  * base --  the basis matrices for the rays
  * filtration --  the filtration matrices of the vector
    bundle
  * details --  the details of a toric vector bundle
  * isGeneral --  checks whether a toric vector bundle is
    general

Ways to use randomDeformation :
===============================

  * "randomDeformation(ToricVectorBundleKlyachko,ZZ)"
  * "randomDeformation(ToricVectorBundleKlyachko,ZZ,ZZ)"

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

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

rank(ToricVectorBundle) --  the rank of the vector bundle
*********************************************************

Synopsis
========

  * Function: rank (Macaulay2Doc),
  * Usage:
        k = rank E
  * Inputs:
      * E, an instance of the type ToricVectorBundle,
  * Outputs:
      * k, an integer (Macaulay2Doc),

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

Returns the rank $k$ of the toric vector bundle in Kaneyama's description.
+-------------------------------------------+
|i1 : E = tangentBundle projectiveSpaceFan 3|
|                                           |
|o1 = {dimension of the variety => 3 }      |
|      number of affine charts => 4         |
|      number of rays => 4                  |
|      rank of the vector bundle => 3       |
|                                           |
|o1 : ToricVectorBundleKlyachko             |
+-------------------------------------------+
|i2 : rank E                                |
|                                           |
|o2 = 3                                     |
+-------------------------------------------+

See also
========

  * rays(ToricVectorBundle) --  the rays of
    the underlying fan
  * fan(ToricVectorBundle) --  the
    underlying fan of a toric vector bundle
  * charts --  the number of maximal affine charts

Ways to use this method:
========================

  * rank(ToricVectorBundle) --  the rank of
    the vector bundle

rays(ToricVectorBundle) --  the rays of the underlying fan
**********************************************************

Synopsis
========

  * Function: rays (OldPolyhedra),
  * Usage:
        L = rays E
  * Inputs:
      * E, an instance of the type ToricVectorBundle,
  * Outputs:
      * L, a list (Macaulay2Doc),

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

Returns the rays of the fan of the underlying toric variety as a list. Each ray
is given as a one column matrix.
+---------------------------------------------+
|i1 : E = cotangentBundle projectiveSpaceFan 2|
|                                             |
|o1 = {dimension of the variety => 2 }        |
|      number of affine charts => 3           |
|      number of rays => 3                    |
|      rank of the vector bundle => 2         |
|                                             |
|o1 : ToricVectorBundleKlyachko               |
+---------------------------------------------+
|i2 : rays E                                  |
|                                             |
|o2 = {| -1 |, | 0 |, | 1 |}                  |
|      | -1 |  | 1 |  | 0 |                   |
|                                             |
|o2 : List                                    |
+---------------------------------------------+

See also
========

  * rank(ToricVectorBundle) --  the rank of
    the vector bundle
  * fan(ToricVectorBundle) --  the
    underlying fan of a toric vector bundle
  * charts --  the number of maximal affine charts

Ways to use this method:
========================

  * rays(ToricVectorBundle) --  the rays of
    the underlying fan

regCheck --  checking the regularity condition for a toric vector bundle
************************************************************************

Synopsis
========

  * Usage:
        b = regCheck E
  * Inputs:
      * E, a vector bundle on a toric variety (Kaneyama's description),
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), whether E satisfies
        the regularity condition

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

"For a toric vector bundle in Kaneyama's description, the regularity condition
means that for every pair of maximal cones $\sigma_1,\sigma_2$intersecting in a
common codimension-one face, the two sets of degrees $d_1,d_2$ and the
transition matrix $A_{1,2}$ fulfil the regularity condition. I.e. for every $i$
and $j$ we have that either the $(i,j)$ entry of the matrix $A_{1,2}$ is $0$ or
the difference of the $i$-th degree vector of $d_1$ of $\sigma_1$ and the
$j$-th degree vector of $d_2$ of $\sigma_2$ is in the dual cone of the
intersection of $\sigma_1$ and $\sigma_2$."

Note that this is only necessary for toric vector bundles generated 'by hand'
using addBaseChange, and addDegrees,
since bundles generated for example by tangentBundle,
satisfy the condition automatically.
+------------------------------------------------------------+
|i1 : E = tangentBundle(pp1ProductFan 2,"Type" => "Kaneyama")|
|                                                            |
|o1 = {dimension of the variety => 2 }                       |
|      number of affine charts => 4                          |
|      rank of the vector bundle => 2                        |
|                                                            |
|o1 : ToricVectorBundleKaneyama                              |
+------------------------------------------------------------+
|i2 : regCheck E                                             |
|                                                            |
|o2 = true                                                   |
+------------------------------------------------------------+

See also
========

  * addBaseChange -- changing the transition matrices of
    a toric vector bundle
  * addDegrees -- changing the degrees of a toric vector
    bundle
  * cocycleCheck --  checks if a toric vector bundle
    fulfills the cocycle condition
  * isVectorBundle --  checks if the data does in fact
    define an equivariant toric vector bundle

Ways to use regCheck :
======================

  * "regCheck(ToricVectorBundleKaneyama)"

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

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

ring(ToricVectorBundle) --  the graded ring of the bundle
*********************************************************

Synopsis
========

  * Function: ring (Macaulay2Doc),
  * Usage:
        R = ring E
  * Inputs:
      * E, an instance of the type ToricVectorBundle,
  * Outputs:
      * R, a ring (Macaulay2Doc),

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

For a vector bundle in Kaneyama's description the graded ring is QQ (Macaulay2Doc),
with degree space the lattice of the underlying fan.
+-----------------------------------------------------------------+
|i1 : E = tangentBundle(projectiveSpaceFan 3,"Type" => "Kaneyama")|
|                                                                 |
|o1 = {dimension of the variety => 3 }                            |
|      number of affine charts => 4                               |
|      rank of the vector bundle => 3                             |
|                                                                 |
|o1 : ToricVectorBundleKaneyama                                   |
+-----------------------------------------------------------------+
|i2 : ring E                                                      |
|                                                                 |
|o2 = QQ[]                                                        |
|                                                                 |
|o2 : PolynomialRing                                              |
+-----------------------------------------------------------------+

For a vector bundle in Klyachko's description the graded ring is QQ (Macaulay2Doc),
with degree space the lattice of the underlying fan.
+-----------------------------------------------------------------------------+
|i3 : E = toricVectorBundle(1,projectiveSpaceFan 2,                           |
|                                                                             |
|o3 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 3                                           |
|      number of rays => 3                                                    |
|      rank of the vector bundle => 1                                         |
|                                                                             |
|o3 : ToricVectorBundleKlyachko                                               |
|-----------------------------------------------------------------------------|
|toList(3:matrix{{1/2}}),toList(3:matrix{{-1}}))                              |
+-----------------------------------------------------------------------------+
|i4 : ring E                                                                  |
|                                                                             |
|o4 = QQ[]                                                                    |
|                                                                             |
|o4 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+

See also
========

  * HH^ZZ ToricVectorBundle --  the i-th
    cohomology group of a toric vector bundle
  * HH^ZZ(ToricVectorBundle,Matrix)
    --  the i-th cohomology of a toric
    vector bundle in a given degree
  * HH^ZZ(ToricVectorBundle,List),
    --  the i-th cohomology of a toric vector bundle for a given list of
    degrees

Ways to use this method:
========================

  * ring(ToricVectorBundle) --  the graded
    ring of the bundle

symmetricPower(ZZ,ToricVectorBundle) --  the 'l'-th symmetric power of a toric vector bundle
********************************************************************************************

Synopsis
========

  * Function: symmetricPower (Macaulay2Doc),
  * Usage:
        Es = symmetricPower(l,E)
  * Inputs:
      * l, an integer (Macaulay2Doc),  strictly positive
      * E, an instance of the type ToricVectorBundle,
  * Outputs:
      * Es, an instance of the type ToricVectorBundle,

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

symmetricPower computes the $l$-th symmetric power of a toric vector bundle in
each description. The resulting bundle will be given in the same description as
the original bundle. $l$ must be strictly positive.
+--------------------------------------------------------+
|i1 : E = tangentBundle hirzebruchFan 3                  |
|                                                        |
|o1 = {dimension of the variety => 2 }                   |
|      number of affine charts => 4                      |
|      number of rays => 4                               |
|      rank of the vector bundle => 2                    |
|                                                        |
|o1 : ToricVectorBundleKlyachko                          |
+--------------------------------------------------------+
|i2 : details E                                          |
|                                                        |
|o2 = HashTable{| -1 | => (| -1 1/3 |, | -1 0 |)}        |
|               | 3  |     | 3  0   |                    |
|               | 0  | => (| 0  1 |, | -1 0 |)           |
|               | -1 |     | -1 0 |                      |
|               | 0 | => (| 0 1 |, | -1 0 |)             |
|               | 1 |     | 1 0 |                        |
|               | 1 | => (| 1 0 |, | -1 0 |)             |
|               | 0 |     | 0 1 |                        |
|                                                        |
|o2 : HashTable                                          |
+--------------------------------------------------------+
|i3 : Es = symmetricPower(2,E)                           |
|                                                        |
|o3 = {dimension of the variety => 2 }                   |
|      number of affine charts => 4                      |
|      number of rays => 4                               |
|      rank of the vector bundle => 3                    |
|                                                        |
|o3 : ToricVectorBundleKlyachko                          |
+--------------------------------------------------------+
|i4 : details Es                                         |
|                                                        |
|o4 = HashTable{| -1 | => (| 1  -1/3 1/9 |, | -2 -1 0 |)}|
|               | 3  |     | -6 1    0   |               |
|                          | 9  0    0   |               |
|               | 0  | => (| 0 0  1 |, | -2 -1 0 |)      |
|               | -1 |     | 0 -1 0 |                    |
|                          | 1 0  0 |                    |
|               | 0 | => (| 0 0 1 |, | -2 -1 0 |)        |
|               | 1 |     | 0 1 0 |                      |
|                         | 1 0 0 |                      |
|               | 1 | => (| 1 0 0 |, | -2 -1 0 |)        |
|               | 0 |     | 0 1 0 |                      |
|                         | 0 0 1 |                      |
|                                                        |
|o4 : HashTable                                          |
+--------------------------------------------------------+

See also
========

  * exteriorPower(ZZ,ToricVectorBundle)
    --  the 'l'-th exterior power of
    a toric vector bundle
  * ToricVectorBundle ++ ToricVectorBundle
    --  the direct sum of two toric vector bundles
  * tensor(ToricVectorBundle,ToricVectorBundle)
    --  the tensor product
    of two toric vector bundles

Ways to use this method:
========================

  * symmetricPower(ZZ,ToricVectorBundle)
    --  the 'l'-th symmetric power
    of a toric vector bundle

tangentBundle --  the tangent bundle on a toric variety
*******************************************************

Synopsis
========

  * Usage:
        E = tangentBundle F
  * Inputs:
      * F, an instance of the type Fan (OldPolyhedra),
  * Optional inputs (Macaulay2Doc),:
      * Type
  * Outputs:
      * E, an instance of the type ToricVectorBundle,

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

If the fan F is pure, of full dimension and smooth, then the function generates
the tangent bundle of the toric variety given by F. If no further options are
given then the resulting bundle will be in Klyachko's description:
+----------------------------------------------+
|i1 : F = pp1ProductFan 2                      |
|                                              |
|o1 = {ambient dimension => 2         }        |
|      number of generating cones => 4         |
|      number of rays => 4                     |
|      top dimension of the cones => 2         |
|                                              |
|o1 : Fan                                      |
+----------------------------------------------+
|i2 : E = tangentBundle F                      |
|                                              |
|o2 = {dimension of the variety => 2 }         |
|      number of affine charts => 4            |
|      number of rays => 4                     |
|      rank of the vector bundle => 2          |
|                                              |
|o2 : ToricVectorBundleKlyachko                |
+----------------------------------------------+
|i3 : details E                                |
|                                              |
|o3 = HashTable{| -1 | => (| -1 0 |, | -1 0 |)}|
|               | 0  |     | 0  1 |            |
|               | 0  | => (| 0  1 |, | -1 0 |) |
|               | -1 |     | -1 0 |            |
|               | 0 | => (| 0 1 |, | -1 0 |)   |
|               | 1 |     | 1 0 |              |
|               | 1 | => (| 1 0 |, | -1 0 |)   |
|               | 0 |     | 0 1 |              |
|                                              |
|o3 : HashTable                                |
+----------------------------------------------+

If the option "Type" => "Kaneyama" is given then the resulting bundle will be
in Kaneyama's description:
+--------------------------------------------------------------------------+
|i4 : F = pp1ProductFan 2                                                  |
|                                                                          |
|o4 = {ambient dimension => 2         }                                    |
|      number of generating cones => 4                                     |
|      number of rays => 4                                                 |
|      top dimension of the cones => 2                                     |
|                                                                          |
|o4 : Fan                                                                  |
+--------------------------------------------------------------------------+
|i5 : E = tangentBundle(F,"Type" => "Kaneyama")                            |
|                                                                          |
|o5 = {dimension of the variety => 2 }                                     |
|      number of affine charts => 4                                        |
|      rank of the vector bundle => 2                                      |
|                                                                          |
|o5 : ToricVectorBundleKaneyama                                            |
+--------------------------------------------------------------------------+
|i6 : details E                                                            |
|                                                                          |
|o6 = (HashTable{0 => (| 1 0 |, | -1 0  |)}, HashTable{(0, 1) => | 1 0  |})|
|                      | 0 1 |  | 0  -1 |                        | 0 -1 |  |
|                1 => (| 1 0  |, | -1 0 |)             (0, 2) => | -1 0 |  |
|                      | 0 -1 |  | 0  1 |                        | 0  1 |  |
|                2 => (| -1 0 |, | 1 0  |)             (1, 3) => | -1 0 |  |
|                      | 0  1 |  | 0 -1 |                        | 0  1 |  |
|                3 => (| -1 0  |, | 1 0 |)             (2, 3) => | 1 0  |  |
|                      | 0  -1 |  | 0 1 |                        | 0 -1 |  |
|                                                                          |
|o6 : Sequence                                                             |
+--------------------------------------------------------------------------+

See also
========

  * cotangentBundle --  the cotangent bundle on a toric
    variety

Ways to use tangentBundle :
===========================

  * "tangentBundle(Fan)"

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

The object tangentBundle, is a method function with options (Macaulay2Doc).

tensor(ToricVectorBundle,ToricVectorBundle) --  the tensor product of two toric vector bundles
**********************************************************************************************

Synopsis
========

  * Function: tensor (Macaulay2Doc),
  * Usage:
        E = tensor(E1,E2)
  * Inputs:
      * E1, an instance of the type ToricVectorBundle,
      * E2, an instance of the type ToricVectorBundle,
  * Outputs:
      * E, an instance of the type ToricVectorBundle,

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

If E1 and E2 are defined over the same fan and are in the same description,
then tensor computes the tensor product of the two vector bundles in this
description.
+------------------------------------------------------------+
|i1 : E1 = toricVectorBundle(2,hirzebruchFan 3)              |
|                                                            |
|o1 = {dimension of the variety => 2 }                       |
|      number of affine charts => 4                          |
|      number of rays => 4                                   |
|      rank of the vector bundle => 2                        |
|                                                            |
|o1 : ToricVectorBundleKlyachko                              |
+------------------------------------------------------------+
|i2 : E2 = tangentBundle hirzebruchFan 3                     |
|                                                            |
|o2 = {dimension of the variety => 2 }                       |
|      number of affine charts => 4                          |
|      number of rays => 4                                   |
|      rank of the vector bundle => 2                        |
|                                                            |
|o2 : ToricVectorBundleKlyachko                              |
+------------------------------------------------------------+
|i3 : E = tensor(E1,E2)                                      |
|                                                            |
|o3 = {dimension of the variety => 2 }                       |
|      number of affine charts => 4                          |
|      number of rays => 4                                   |
|      rank of the vector bundle => 4                        |
|                                                            |
|o3 : ToricVectorBundleKlyachko                              |
+------------------------------------------------------------+
|i4 : details E                                              |
|                                                            |
|o4 = HashTable{| -1 | => (| -1 1/3 0  0   |, | -1 0 -1 0 |)}|
|               | 3  |     | 3  0   0  0   |                 |
|                          | 0  0   -1 1/3 |                 |
|                          | 0  0   3  0   |                 |
|               | 0  | => (| 0  1 0  0 |, | -1 0 -1 0 |)     |
|               | -1 |     | -1 0 0  0 |                     |
|                          | 0  0 0  1 |                     |
|                          | 0  0 -1 0 |                     |
|               | 0 | => (| 0 1 0 0 |, | -1 0 -1 0 |)        |
|               | 1 |     | 1 0 0 0 |                        |
|                         | 0 0 0 1 |                        |
|                         | 0 0 1 0 |                        |
|               | 1 | => (| 1 0 0 0 |, | -1 0 -1 0 |)        |
|               | 0 |     | 0 1 0 0 |                        |
|                         | 0 0 1 0 |                        |
|                         | 0 0 0 1 |                        |
|                                                            |
|o4 : HashTable                                              |
+------------------------------------------------------------+

See also
========

  * ToricVectorBundle ** ToricVectorBundle
    --  the tensor product of two toric vector bundles
  * ToricVectorBundle ++ ToricVectorBundle
    --  the direct sum of two toric vector bundles
  * exteriorPower(ZZ,ToricVectorBundle)
    --  the 'l'-th exterior power of
    a toric vector bundle
  * symmetricPower(ZZ,ToricVectorBundle)
    --  the 'l'-th symmetric power
    of a toric vector bundle

Ways to use this method:
========================

  * tensor(ToricVectorBundle,ToricVectorBundle)
    --  the tensor product
    of two toric vector bundles

ToricVectorBundle -- the class of all toric vector bundles
**********************************************************

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

In OldToricVectorBundles, an equivariant vector bundle on some toric
variety is given as an object of class ToricVectorBundle which can be given in
two descriptions:
  * By a collection of vector spaces with filtration for each ray of the
    underlying fan, see ToricVectorBundleKlyachko.
  * By a set of degree vectors for each maximal cone and a transition matrix
    for each pair of maximal cones of the underlying fan, see
    ToricVectorBundleKaneyama.

For more detailed descriptions see the corresponding pages of the two subtypes.

See also
========

  * ToricVectorBundleKlyachko -- the class of
    all toric vector bundles in Klyachko's description
  * ToricVectorBundleKaneyama -- the class of
    all toric vector bundles in Kaneyama's description

Types of ToricVectorBundle :
============================

  * ToricVectorBundleKaneyama -- the class of
    all toric vector bundles in Kaneyama's description
  * ToricVectorBundleKlyachko -- the class of
    all toric vector bundles in Klyachko's description

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

  * exteriorPower(ZZ,ToricVectorBundle)
    --  the 'l'-th exterior power of
    a toric vector bundle
  * tensor(ToricVectorBundle,ToricVectorBundle)
    --  the tensor product
    of two toric vector bundles

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

  * "charts(ToricVectorBundle)" -- see charts, --  the number of
    maximal affine charts
  * "deltaE(ToricVectorBundle)" -- see deltaE, --  the polytope
    of possible degrees that give non zero cohomology
  * "details(ToricVectorBundle)" -- see details, --  the details
    of a toric vector bundle
  * dual(ToricVectorBundle) --  the dual
    bundle of a toric vector bundle
  * "eulerChi(Matrix,ToricVectorBundle)" -- see eulerChi, --
    the Euler characteristic of a toric vector bundle
  * "eulerChi(ToricVectorBundle)" -- see eulerChi, --  the
    Euler characteristic of a toric vector bundle
  * fan(ToricVectorBundle) --  the
    underlying fan of a toric vector bundle
  * HH^ZZ ToricVectorBundle --  the i-th
    cohomology group of a toric vector bundle
  * hh^ZZ ToricVectorBundle --  the rank of the
    i-th cohomology group of a toric vector bundle
  * HH^ZZ(ToricVectorBundle,List),
    --  the i-th cohomology of a toric vector bundle for a given list of
    degrees
  * HH^ZZ(ToricVectorBundle,Matrix)
    --  the i-th cohomology of a toric
    vector bundle in a given degree
  * "isVectorBundle(ToricVectorBundle)" -- see isVectorBundle,
    --  checks if the data does in fact define an equivariant
    toric vector bundle
  * maxCones(ToricVectorBundle) --  the
    list of maximal cones of the underlying fan
  * rank(ToricVectorBundle) --  the rank of
    the vector bundle
  * rays(ToricVectorBundle) --  the rays of
    the underlying fan
  * ring(ToricVectorBundle) --  the graded
    ring of the bundle
  * symmetricPower(ZZ,ToricVectorBundle)
    --  the 'l'-th symmetric power
    of a toric vector bundle
  * ToricVectorBundle ** ToricVectorBundle
    --  the tensor product of two toric vector bundles
  * ToricVectorBundle ++ ToricVectorBundle
    --  the direct sum of two toric vector bundles
  * ToricVectorBundle == ToricVectorBundle
    --  checks for equality

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

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

toricVectorBundle --  the trivial bundle of rank 'k' for a given fan
********************************************************************

Synopsis
========

  * Usage:
        E = toricVectorBundle(k,F)
  * Inputs:
      * k, an integer (Macaulay2Doc),  strictly positive
      * F, an object of class Fan
  * Outputs:
      * E, an instance of the type ToricVectorBundle,

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

For a given pure, full dimensional and pointed Fan F the function
toricVectorBundle generates the trivial toric vector bundle of rank k.

"If no further options are given then the resulting bundle will be in
Klyachko's description: The basis assigned to every ray is the standard basis
of $\mathbb{Q}^k$ and the filtration is given by $0$ for all $i<0$ and
$\mathbb{Q}^k$ for $i>=0$."
+--------------------------------------------------+
|i1 : E = toricVectorBundle(2,projectiveSpaceFan 2)|
|                                                  |
|o1 = {dimension of the variety => 2 }             |
|      number of affine charts => 3                |
|      number of rays => 3                         |
|      rank of the vector bundle => 2              |
|                                                  |
|o1 : ToricVectorBundleKlyachko                    |
+--------------------------------------------------+
|i2 : details E                                    |
|                                                  |
|o2 = HashTable{| -1 | => (| 1 0 |, 0)}            |
|               | -1 |     | 0 1 |                 |
|               | 0 | => (| 1 0 |, 0)              |
|               | 1 |     | 0 1 |                  |
|               | 1 | => (| 1 0 |, 0)              |
|               | 0 |     | 0 1 |                  |
|                                                  |
|o2 : HashTable                                    |
+--------------------------------------------------+

If the option "Type" => "Kaneyama" is given then the resulting bundle will be
in Kaneyama's description: The degree vectors of this bundle are all zero
vectors and the transition matrices are all the identity. Note that for
Kaneyama's description only complete, pointed fans are implemented and thus a
non complete fan will produce an error.
+-------------------------------------------------------------------+
|i3 : E = toricVectorBundle(2,pp1ProductFan 2,"Type" => "Kaneyama") |
|                                                                   |
|o3 = {dimension of the variety => 2 }                              |
|      number of affine charts => 4                                 |
|      rank of the vector bundle => 2                               |
|                                                                   |
|o3 : ToricVectorBundleKaneyama                                     |
+-------------------------------------------------------------------+
|i4 : details E                                                     |
|                                                                   |
|o4 = (HashTable{0 => (| 1 0 |, 0)  }, HashTable{(0, 1) => | 1 0 |})|
|                      | 0 1 |                             | 0 1 |  |
|                1 => (| 1 0  |, 0)              (0, 2) => | 1 0 |  |
|                      | 0 -1 |                            | 0 1 |  |
|                2 => (| -1 0 |, 0)              (1, 3) => | 1 0 |  |
|                      | 0  1 |                            | 0 1 |  |
|                3 => (| -1 0  |, 0)             (2, 3) => | 1 0 |  |
|                      | 0  -1 |                           | 0 1 |  |
|                                                                   |
|o4 : Sequence                                                      |
+-------------------------------------------------------------------+

See also
========

  * addBaseChange -- changing the transition matrices of
    a toric vector bundle
  * addDegrees -- changing the degrees of a toric vector
    bundle
  * addBase -- changing the basis matrices of a toric vector
    bundle in Klyachko's description
  * addFiltration -- changing the filtration matrices of
    a toric vector bundle in Klyachko's description
  * details --  the details of a toric vector bundle
  * regCheck --  checking the regularity condition for a toric
    vector bundle
  * cocycleCheck --  checks if a toric vector bundle
    fulfills the cocycle condition
  * isVectorBundle --  checks if the data does in fact
    define an equivariant toric vector bundle

Ways to use toricVectorBundle :
===============================

  * "toricVectorBundle(ZZ,Fan)"
  * toricVectorBundle(ZZ,Fan,List,List)
    --  a toric vector bundle of
    rank 'k' with given filtrations or degrees

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

The object toricVectorBundle, is a method function with options (Macaulay2Doc).

ToricVectorBundle ** ToricVectorBundle --  the tensor product of two toric vector bundles
*****************************************************************************************

Synopsis
========

  * Operator: ** (Macaulay2Doc),
  * Usage:
        E = E1 ** E2
  * Inputs:
      * E1, an instance of the type ToricVectorBundle,
      * E2, an instance of the type ToricVectorBundle,
  * Outputs:
      * E, an instance of the type ToricVectorBundle,

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

If $E_1$ and $E_2$ are defined over the same fan and in the same description,
then tensor computes the tensor product of the two vector bundles in this
description
+------------------------------------------------------------+
|i1 : E1 = toricVectorBundle(2,hirzebruchFan 3)              |
|                                                            |
|o1 = {dimension of the variety => 2 }                       |
|      number of affine charts => 4                          |
|      number of rays => 4                                   |
|      rank of the vector bundle => 2                        |
|                                                            |
|o1 : ToricVectorBundleKlyachko                              |
+------------------------------------------------------------+
|i2 : E2 = tangentBundle hirzebruchFan 3                     |
|                                                            |
|o2 = {dimension of the variety => 2 }                       |
|      number of affine charts => 4                          |
|      number of rays => 4                                   |
|      rank of the vector bundle => 2                        |
|                                                            |
|o2 : ToricVectorBundleKlyachko                              |
+------------------------------------------------------------+
|i3 : E = E1 ** E2                                           |
|                                                            |
|o3 = {dimension of the variety => 2 }                       |
|      number of affine charts => 4                          |
|      number of rays => 4                                   |
|      rank of the vector bundle => 4                        |
|                                                            |
|o3 : ToricVectorBundleKlyachko                              |
+------------------------------------------------------------+
|i4 : details E                                              |
|                                                            |
|o4 = HashTable{| -1 | => (| -1 1/3 0  0   |, | -1 0 -1 0 |)}|
|               | 3  |     | 3  0   0  0   |                 |
|                          | 0  0   -1 1/3 |                 |
|                          | 0  0   3  0   |                 |
|               | 0  | => (| 0  1 0  0 |, | -1 0 -1 0 |)     |
|               | -1 |     | -1 0 0  0 |                     |
|                          | 0  0 0  1 |                     |
|                          | 0  0 -1 0 |                     |
|               | 0 | => (| 0 1 0 0 |, | -1 0 -1 0 |)        |
|               | 1 |     | 1 0 0 0 |                        |
|                         | 0 0 0 1 |                        |
|                         | 0 0 1 0 |                        |
|               | 1 | => (| 1 0 0 0 |, | -1 0 -1 0 |)        |
|               | 0 |     | 0 1 0 0 |                        |
|                         | 0 0 1 0 |                        |
|                         | 0 0 0 1 |                        |
|                                                            |
|o4 : HashTable                                              |
+------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i5 : E1 = toricVectorBundle(2,hirzebruchFan 3,"Type" => "Kaneyama")          |
|                                                                             |
|o5 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o5 : ToricVectorBundleKaneyama                                               |
+-----------------------------------------------------------------------------+
|i6 : E2 = tangentBundle(hirzebruchFan 3,"Type" => "Kaneyama")                |
|                                                                             |
|o6 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o6 : ToricVectorBundleKaneyama                                               |
+-----------------------------------------------------------------------------+
|i7 : E = E1 ** E2                                                            |
|                                                                             |
|o7 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      rank of the vector bundle => 4                                         |
|                                                                             |
|o7 : ToricVectorBundleKaneyama                                               |
+-----------------------------------------------------------------------------+
|i8 : details E                                                               |
|                                                                             |
|o8 = (HashTable{0 => (| 0 -1 |, | 1 1 -3 -3 |) }, HashTable{(0, 1) => |      |
|                      | 1 3  |  | 0 0 -1 -1 |                         |      |
|                1 => (| 0  -1 |, | 1 1 3 3 |)                         |      |
|                      | -1 3  |  | 0 0 1 1 |                          |      |
|                2 => (| 1 0 |, | -1 -1 0  0  |)             (0, 2) => |      |
|                      | 0 1 |  | 0  0  -1 -1 |                        |      |
|                3 => (| 1 0  |, | -1 -1 0 0 |)                        |      |
|                      | 0 -1 |  | 0  0  1 1 |                         |      |
|                                                            (1, 3) => |      |
|                                                                      |      |
|                                                                      |      |
|                                                                      |      |
|                                                            (2, 3) => |      |
|                                                                      |      |
|                                                                      |      |
|                                                                      |      |
|     ------------------------------------------------------------------------|
|     1 0 0  0  |})                                                           |
|     0 1 0  0  |                                                             |
|     0 0 -1 0  |                                                             |
|     0 0 0  -1 |                                                             |
|     -1 0  0 0 |                                                             |
|     0  -1 0 0 |                                                             |
|     3  0  1 0 |                                                             |
|     0  3  0 1 |                                                             |
|     -1 0  0 0 |                                                             |
|     0  -1 0 0 |                                                             |
|     -3 0  1 0 |                                                             |
|     0  -3 0 1 |                                                             |
|     1 0 0  0  |                                                             |
|     0 1 0  0  |                                                             |
|     0 0 -1 0  |                                                             |
|     0 0 0  -1 |                                                             |
|                                                                             |
|o8 : Sequence                                                                |
+-----------------------------------------------------------------------------+

See also
========

  * tensor(ToricVectorBundle,ToricVectorBundle)
    --  the tensor product
    of two toric vector bundles
  * ToricVectorBundle ++ ToricVectorBundle
    --  the direct sum of two toric vector bundles
  * exteriorPower(ZZ,ToricVectorBundle)
    --  the 'l'-th exterior power of
    a toric vector bundle
  * symmetricPower(ZZ,ToricVectorBundle)
    --  the 'l'-th symmetric power
    of a toric vector bundle

Ways to use this method:
========================

  * ToricVectorBundle ** ToricVectorBundle
    --  the tensor product of two toric vector bundles

ToricVectorBundle ++ ToricVectorBundle --  the direct sum of two toric vector bundles
*************************************************************************************

Synopsis
========

  * Operator: ++ (Macaulay2Doc),
  * Usage:
        E = E1 ++ E2
  * Inputs:
      * E1, an instance of the type ToricVectorBundle,
      * E2, an instance of the type ToricVectorBundle,
  * Outputs:
      * E, an instance of the type ToricVectorBundle,

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

If $E_1$ and $E_2$ are defined over the same fan, then directSum computes the
direct sum of the two vector bundles. The bundles must both be given in the
same description and the resulting bundle will be in this description.
+--------------------------------------------------------+
|i1 : E1 = toricVectorBundle(2,hirzebruchFan 3)          |
|                                                        |
|o1 = {dimension of the variety => 2 }                   |
|      number of affine charts => 4                      |
|      number of rays => 4                               |
|      rank of the vector bundle => 2                    |
|                                                        |
|o1 : ToricVectorBundleKlyachko                          |
+--------------------------------------------------------+
|i2 : E2 = tangentBundle hirzebruchFan 3                 |
|                                                        |
|o2 = {dimension of the variety => 2 }                   |
|      number of affine charts => 4                      |
|      number of rays => 4                               |
|      rank of the vector bundle => 2                    |
|                                                        |
|o2 : ToricVectorBundleKlyachko                          |
+--------------------------------------------------------+
|i3 : E = E1 ++ E2                                       |
|                                                        |
|o3 = {dimension of the variety => 2 }                   |
|      number of affine charts => 4                      |
|      number of rays => 4                               |
|      rank of the vector bundle => 4                    |
|                                                        |
|o3 : ToricVectorBundleKlyachko                          |
+--------------------------------------------------------+
|i4 : details E                                          |
|                                                        |
|o4 = HashTable{| -1 | => (| 1 0 0  0   |, | 0 0 -1 0 |)}|
|               | 3  |     | 0 1 0  0   |                |
|                          | 0 0 -1 1/3 |                |
|                          | 0 0 3  0   |                |
|               | 0  | => (| 1 0 0  0 |, | 0 0 -1 0 |)   |
|               | -1 |     | 0 1 0  0 |                  |
|                          | 0 0 0  1 |                  |
|                          | 0 0 -1 0 |                  |
|               | 0 | => (| 1 0 0 0 |, | 0 0 -1 0 |)     |
|               | 1 |     | 0 1 0 0 |                    |
|                         | 0 0 0 1 |                    |
|                         | 0 0 1 0 |                    |
|               | 1 | => (| 1 0 0 0 |, | 0 0 -1 0 |)     |
|               | 0 |     | 0 1 0 0 |                    |
|                         | 0 0 1 0 |                    |
|                         | 0 0 0 1 |                    |
|                                                        |
|o4 : HashTable                                          |
+--------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i5 : E1 = toricVectorBundle(2,hirzebruchFan 3,"Type" => "Kaneyama")          |
|                                                                             |
|o5 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o5 : ToricVectorBundleKaneyama                                               |
+-----------------------------------------------------------------------------+
|i6 : E2 = tangentBundle(hirzebruchFan 3,"Type" => "Kaneyama")                |
|                                                                             |
|o6 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o6 : ToricVectorBundleKaneyama                                               |
+-----------------------------------------------------------------------------+
|i7 : E = E1 ++ E2                                                            |
|                                                                             |
|o7 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 4                                           |
|      rank of the vector bundle => 4                                         |
|                                                                             |
|o7 : ToricVectorBundleKaneyama                                               |
+-----------------------------------------------------------------------------+
|i8 : details E                                                               |
|                                                                             |
|o8 = (HashTable{0 => (| 0 -1 |, | 0 0 1 -3 |)}, HashTable{(0, 1) => | 1 0    |
|                      | 1 3  |  | 0 0 0 -1 |                        | 0 1    |
|                1 => (| 0  -1 |, | 0 0 1 3 |)                       | 0 0    |
|                      | -1 3  |  | 0 0 0 1 |                        | 0 0    |
|                2 => (| 1 0 |, | 0 0 -1 0  |)             (0, 2) => | 1 0    |
|                      | 0 1 |  | 0 0 0  -1 |                        | 0 1    |
|                3 => (| 1 0  |, | 0 0 -1 0 |)                       | 0 0    |
|                      | 0 -1 |  | 0 0 0  1 |                        | 0 0    |
|                                                          (1, 3) => | 1 0    |
|                                                                    | 0 1    |
|                                                                    | 0 0    |
|                                                                    | 0 0    |
|                                                          (2, 3) => | 1 0    |
|                                                                    | 0 1    |
|                                                                    | 0 0    |
|                                                                    | 0 0    |
|     ------------------------------------------------------------------------|
|     0 0  |})                                                                |
|     0 0  |                                                                  |
|     1 0  |                                                                  |
|     0 -1 |                                                                  |
|     0  0 |                                                                  |
|     0  0 |                                                                  |
|     -1 0 |                                                                  |
|     3  1 |                                                                  |
|     0  0 |                                                                  |
|     0  0 |                                                                  |
|     -1 0 |                                                                  |
|     -3 1 |                                                                  |
|     0 0  |                                                                  |
|     0 0  |                                                                  |
|     1 0  |                                                                  |
|     0 -1 |                                                                  |
|                                                                             |
|o8 : Sequence                                                                |
+-----------------------------------------------------------------------------+

See also
========

  * ToricVectorBundle ** ToricVectorBundle
    --  the tensor product of two toric vector bundles
  * tensor(ToricVectorBundle,ToricVectorBundle)
    --  the tensor product
    of two toric vector bundles
  * exteriorPower(ZZ,ToricVectorBundle)
    --  the 'l'-th exterior power of
    a toric vector bundle
  * symmetricPower(ZZ,ToricVectorBundle)
    --  the 'l'-th symmetric power
    of a toric vector bundle

Ways to use this method:
========================

  * ToricVectorBundle ++ ToricVectorBundle
    --  the direct sum of two toric vector bundles

ToricVectorBundle == ToricVectorBundle --  checks for equality
**************************************************************

Synopsis
========

  * Operator: == (Macaulay2Doc),
  * Usage:
        b = E1 == E2
  * Inputs:
      * E1, an instance of the type ToricVectorBundle,
      * E2, an instance of the type ToricVectorBundle,
  * Outputs:
      * E, a Boolean value (Macaulay2Doc),  whether the two
        toric vector bundles are equal

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

Checks if two toric vector bundles are identical. This only works if they are
given in the same description.
+----------------------------------------------+
|i1 : E1 = toricVectorBundle(2,hirzebruchFan 3)|
|                                              |
|o1 = {dimension of the variety => 2 }         |
|      number of affine charts => 4            |
|      number of rays => 4                     |
|      rank of the vector bundle => 2          |
|                                              |
|o1 : ToricVectorBundleKlyachko                |
+----------------------------------------------+
|i2 : E2 = tangentBundle hirzebruchFan 3       |
|                                              |
|o2 = {dimension of the variety => 2 }         |
|      number of affine charts => 4            |
|      number of rays => 4                     |
|      rank of the vector bundle => 2          |
|                                              |
|o2 : ToricVectorBundleKlyachko                |
+----------------------------------------------+
|i3 : E1 == E2                                 |
|                                              |
|o3 = false                                    |
+----------------------------------------------+
+-------------------------------------------------------------------+
|i4 : E1 = toricVectorBundle(2,hirzebruchFan 3,"Type" => "Kaneyama")|
|                                                                   |
|o4 = {dimension of the variety => 2 }                              |
|      number of affine charts => 4                                 |
|      rank of the vector bundle => 2                               |
|                                                                   |
|o4 : ToricVectorBundleKaneyama                                     |
+-------------------------------------------------------------------+
|i5 : E2 = tangentBundle(hirzebruchFan 3,"Type" => "Kaneyama")      |
|                                                                   |
|o5 = {dimension of the variety => 2 }                              |
|      number of affine charts => 4                                 |
|      rank of the vector bundle => 2                               |
|                                                                   |
|o5 : ToricVectorBundleKaneyama                                     |
+-------------------------------------------------------------------+
|i6 : E1 == E2                                                      |
|                                                                   |
|o6 = false                                                         |
+-------------------------------------------------------------------+

See also
========

  * areIsomorphic -- checks if two vector bundles are
    isomorphic
  * isomorphism --  the isomorphism if the two bundles are
    isomorphic

Ways to use this method:
========================

  * ToricVectorBundle == ToricVectorBundle
    --  checks for equality

toricVectorBundle(ZZ,Fan,List,List) --  a toric vector bundle of rank 'k' with given filtrations or degrees
***********************************************************************************************************

Synopsis
========

  * Function: toricVectorBundle,
  * Usage:
        E = toricVectorBundle(k,F,L1,L2)
  * Inputs:
      * k, an integer (Macaulay2Doc),  strictly positive
      * F, an instance of the type Fan (OldPolyhedra), an object of
        class Fan
      * L1, a list (Macaulay2Doc),
      * L2, a list (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Type
  * Outputs:
      * E, an instance of the type ToricVectorBundle,

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

For a given pure, full dimensional and pointed fan F the function
toricVectorBundle generates the toric vector bundle of rank k given by the data
in the two lists L1 and L2.

If no further options are given then the resulting bundle will be in Klyachko's
description: The first list L1 will give the basis matrices and the second list
L2 will give the filtration matrices. Then the resulting vector bundle will
have these basis and filtration matrices. The number of matrices in L1 must
match the number of rays of the fan and they must be in GL(k,$R$) for $R$ being
ZZ (Macaulay2Doc), or QQ (Macaulay2Doc). They will be
assigned to the rays in the order they appear in rays F. The number of
matrices in L2 must also match the number of rays, and they must be $1$ times k
matrices over ZZ (Macaulay2Doc). The assignment order is the same as
for the basis matrices.

Note that the basis and filtration matrices that are given to the function need
not satisfy the compatibility condition. This can by checked by using
regCheck.
+--------------------------------------------------------------------------+
|i1 : L1 = {matrix {{1,0},{0,1}},matrix{{0,1},{1,0}},matrix{{-1,0},{-1,1}}}|
|                                                                          |
|o1 = {| 1 0 |, | 0 1 |, | -1 0 |}                                         |
|      | 0 1 |  | 1 0 |  | -1 1 |                                          |
|                                                                          |
|o1 : List                                                                 |
+--------------------------------------------------------------------------+
|i2 : L2 = {matrix {{-1,0}},matrix{{-2,-1}},matrix{{0,1}}}                 |
|                                                                          |
|o2 = {| -1 0 |, | -2 -1 |, | 0 1 |}                                       |
|                                                                          |
|o2 : List                                                                 |
+--------------------------------------------------------------------------+
|i3 : E = toricVectorBundle(2,projectiveSpaceFan 2,L1,L2)                  |
|                                                                          |
|o3 = {dimension of the variety => 2 }                                     |
|      number of affine charts => 3                                        |
|      number of rays => 3                                                 |
|      rank of the vector bundle => 2                                      |
|                                                                          |
|o3 : ToricVectorBundleKlyachko                                            |
+--------------------------------------------------------------------------+
|i4 : details E                                                            |
|                                                                          |
|o4 = HashTable{| -1 | => (| 1 0 |, | -1 0 |)}                             |
|               | -1 |     | 0 1 |                                         |
|               | 0 | => (| 0 1 |, | -2 -1 |)                              |
|               | 1 |     | 1 0 |                                          |
|               | 1 | => (| -1 0 |, | 0 1 |)                               |
|               | 0 |     | -1 1 |                                         |
|                                                                          |
|o4 : HashTable                                                            |
+--------------------------------------------------------------------------+

If the option "Type" => "Kaneyama" is given then the resulting bundle will be
in Kaneyama's description; Note that this is only implemented for complete,
pointed fans: The first list L1 will give the degree matrices and the second
list L2 will give the transition matrices. The number of matrices in L1 must
match the number of maximal cones of the fan and they must be $n$ times k
matrices over ZZ (Macaulay2Doc). They will be assigned to the cones
in the order they appear in maxCones F. The number of matrices in L2 must match
the number of pairs of maximal cones that intersect in a common codimension-one
face and must all be in GL(k,see QQ (Macaulay2Doc)). They will be
assigned to the pairs $(i,j)$ in lexicographic order.

Note that the degrees and transition matrices that are given to the function
need not satisfy the regularity or the cocycle condition. These can be checked
by using regCheck, and cocycleCheck.
+-----------------------------------------------------------------------------+
|i5 : L1 = {matrix {{1,0},{0,1}},matrix{{0,1},{1,0}},matrix{{-1,0},{-1,1}}}   |
|                                                                             |
|o5 = {| 1 0 |, | 0 1 |, | -1 0 |}                                            |
|      | 0 1 |  | 1 0 |  | -1 1 |                                             |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : L2 = {matrix {{-1,0},{0,-1}},matrix{{0,1},{1,0}},matrix{{0,-1},{-1,0}}} |
|                                                                             |
|o6 = {| -1 0  |, | 0 1 |, | 0  -1 |}                                         |
|      | 0  -1 |  | 1 0 |  | -1 0  |                                          |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+
|i7 : E = toricVectorBundle(2,projectiveSpaceFan 2,L1,L2,"Type" => "Kaneyama")|
|                                                                             |
|o7 = {dimension of the variety => 2 }                                        |
|      number of affine charts => 3                                           |
|      rank of the vector bundle => 2                                         |
|                                                                             |
|o7 : ToricVectorBundleKaneyama                                               |
+-----------------------------------------------------------------------------+
|i8 : details E                                                               |
|                                                                             |
|o8 = (HashTable{0 => (| -1 0 |, | 1 0 |) }, HashTable{(0, 1) => | -1 0  |})  |
|                      | -1 1 |  | 0 1 |                         | 0  -1 |    |
|                1 => (| 1 0 |, | 0 1 |)               (0, 2) => | 0 1 |      |
|                      | 0 1 |  | 1 0 |                          | 1 0 |      |
|                2 => (| 1 -1 |, | -1 0 |)             (1, 2) => | 0  -1 |    |
|                      | 0 -1 |  | -1 1 |                        | -1 0  |    |
|                                                                             |
|o8 : Sequence                                                                |
+-----------------------------------------------------------------------------+

See also
========

  * addBaseChange -- changing the transition matrices of
    a toric vector bundle
  * addDegrees -- changing the degrees of a toric vector
    bundle
  * addBase -- changing the basis matrices of a toric vector
    bundle in Klyachko's description
  * addFiltration -- changing the filtration matrices of
    a toric vector bundle in Klyachko's description
  * details --  the details of a toric vector bundle
  * regCheck --  checking the regularity condition for a toric
    vector bundle
  * cocycleCheck --  checks if a toric vector bundle
    fulfills the cocycle condition
  * isVectorBundle --  checks if the data does in fact
    define an equivariant toric vector bundle

Ways to use this method:
========================

  * toricVectorBundle(ZZ,Fan,List,List)
    --  a toric vector bundle of
    rank 'k' with given filtrations or degrees

ToricVectorBundleKaneyama -- the class of all toric vector bundles in Kaneyama's description
********************************************************************************************

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

"Consider an equivariant vector bundle $E$ of rank $k$ on a toric variety $X$
corresponding to a fan $\Sigma$. Then $E$ is trivial on any invariant open
affine subvariety of $X$ and moreover homogeneously generated by $k$ elements.
Furthermore, the transition maps between these trivializations are homogeneous
of degree zero. Thus, after fixing local homogeneous generators, we get a list
of degrees of generators for each cone in $\Sigma$, along with a transition map
for each pair of cones. Conversely, given a list of $k$ degrees for every cone
of $\Sigma$ along with transition maps satisfying compatibility and regularity
conditions for every pair of cones, one can construct an equivariant vector
bundle of rank $k$ on $X$."

"This description of equivariant vector bundles, due to Kaneyama, is
implemented for complete, pointed fans in the following way: It is only
necessary to consider charts corresponding to maximal dimensional cones of
$\Sigma$. Furthermore, each codimension-one cone of $\Sigma$ corresponds to a
pair of maximal dimensional cones, and thus to a transition map. Due to the
compatibility condition for transition maps, one can reconstruct the transition
map corresponding to an arbitrary pair from the maps of this sort. If the
dimension of $\Sigma$ is $n$ then for each maximal dimensional cone the degree
list of the corresponding chart is saved as an $n$ times $k$ matrix over ",TO
ZZ,", giving $k$ degree vectors in the dual lattice of the fan, one for each
local generator of the bundle. Additionally, for every pair of maximal cones
intersecting in a common codimension-one face, there is a matrix in GL($k$,",TO
QQ,"), representing the transition map between these two affine charts. Indeed,
suppose that cones $\sigma_1$ and $\sigma_1$ intersect in some codimension-one
face, with corresponding affine charts $U_1$ and $U_2$. Then on the
intersection, the $i$-th generator for $U_1$ has a unique representation as a
linear combination in the generators for $U_2$ after being multiplied with
characters to all have the required degree. The coefficients in this
representation form the $i$-th column of the desired matrix."

"We briefly consider the example of  $\mathbb{P}^2$, corresponding to the
complete fan with rays through $(0,1)$, $(1,0)$, and $(-1,-1)$. Denote by $x$
the character of weight $[1,0]$ and by $y$ the character of weight $[0,1]$. Now
the coordinate rings of the three standard affine charts of $\mathbb{P}^2$ are
generated by respectively $(x^{ -1},x^{ -1}y)$, $(x,y)$, and $(xy^{ -1},y^{
-1})$. This means that the modules of differentials are generated by
respectively $(d(x^{ -1}),d(x^{ -1}y))$, $(dx,dy)$, and $(d(xy^{ -1}),d(y^{
-1}))$. These modules give us local trivializations of the cotangent bundle on
$\mathbb{P}^2$. The degrees of the generators for the first chart then are
$[-1,0]$ and $[-1,1]$, for example. Now, since $d(x^{ -1})=-x^{ -2}dx$ and
$d(x^{ -1}y) = -x^{ -2}ydx + x^{ -1}dy$, we get that the transition map between
the generators of the first and second chart is given by the matrix with
columns $(-1,0)$ and $(-1,1)$."

An instance of class ToricVectorBundleKlyachko, when displayed or printed,
gives an overview  of the characteristics of the bundle:
+-------------------------------------------------------------------+
|i1 : E = cotangentBundle(projectiveSpaceFan 2,"Type" => "Kaneyama")|
|                                                                   |
|o1 = {dimension of the variety => 2 }                              |
|      number of affine charts => 3                                 |
|      rank of the vector bundle => 2                               |
|                                                                   |
|o1 : ToricVectorBundleKaneyama                                     |
+-------------------------------------------------------------------+

To see all relevant details of a bundle use details. The data
described above is all stored in a single hash table. In the example from
above, the first chart has the key 0, and transition map described above has
key (0,1):
+----------------------------------------------------------------------------+
|i2 : details E                                                              |
|                                                                            |
|o2 = (HashTable{0 => (| -1 0 |, | -1 -1 |)}, HashTable{(0, 1) => | -1 -1 |})|
|                      | -1 1 |  | 0  1  |                        | 0  1  |  |
|                1 => (| 1 0 |, | 1 0 |)                (0, 2) => | 1  0  |  |
|                      | 0 1 |  | 0 1 |                           | -1 -1 |  |
|                2 => (| 1 -1 |, | 0  1  |)             (1, 2) => | -1 -1 |  |
|                      | 0 -1 |  | -1 -1 |                        | 1  0  |  |
|                                                                            |
|o2 : Sequence                                                               |
+----------------------------------------------------------------------------+

Caveat
======

This implementation only supports vector bundles where the corresponding
transition maps have coefficients in QQ (Macaulay2Doc).

See also
========

  * ToricVectorBundleKlyachko -- the class of
    all toric vector bundles in Klyachko's description
  * ToricVectorBundle -- the class of all toric
    vector bundles

Functions and methods returning a vector bundle on a toric variety (Kaneyama's description) :
=============================================================================================

  * addBaseChange -- changing the transition matrices of
    a toric vector bundle
  * addDegrees -- changing the degrees of a toric vector
    bundle

Methods that use a vector bundle on a toric variety (Kaneyama's description) :
==============================================================================

  * "addBaseChange(ToricVectorBundleKaneyama,List)" -- see addBaseChange,
    -- changing the transition matrices of a toric vector bundle
  * "addDegrees(ToricVectorBundleKaneyama,List)" -- see addDegrees,
    -- changing the degrees of a toric vector bundle
  * "cocycleCheck(ToricVectorBundleKaneyama)" -- see cocycleCheck,
    --  checks if a toric vector bundle fulfills the cocycle
    condition
  * net(ToricVectorBundleKaneyama),
    -- displays characteristics of a toric vector bundle
  * "regCheck(ToricVectorBundleKaneyama)" -- see regCheck, --
    checking the regularity condition for a toric vector bundle

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

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

ToricVectorBundleKlyachko -- the class of all toric vector bundles in Klyachko's description
********************************************************************************************

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

"A toric vector bundle on a toric variety $X$ is a locally free sheaf $E$
together with an action of the torus $T$ on the geometric vector bundle $V(E)$
such that the projection to the base $X$ is equivariant, and the action of $T$
on the fibers is linear. There also is an induced action of $T$ on the local
sections $s \in{}  \Gamma(U,E)$ given by $(t*s)(x) = t^{ -1}(s(t x))$ . This
implies that a regular section $x^u \in{}  \Gamma(X,O_X)$ for an element $u$ in
the character lattice $M$ also has weight $u$. Other choices for the induced
action are possible. In fact, the upper one is different from Klyachko's in his
original description where $x^u \in{}  \Gamma(X,O_X)$ has weight $-u$. We
denote by $E_0$ the fiber over the unit $t_0 \in{} T$, and by $U_\sigma \subset
X$ the open affine torus invariant subset associated with the cone $\sigma$.
The primitive generator of the ray $\rho$ in the fan $\Sigma$ is denoted by
$v_\rho$. Evaluating local homogeneous sections $\Gamma(U_{\rho},E)_u$ of
weight $u$ at $t_0$ provides us with an embedding of these finite dimensional
vector spaces into $E_0$. One can show that the upper choice of the induced
torus action implies that the image of $\Gamma(U_\rho,E)_{u_1}$ is contained in
the image of $\Gamma(U_\rho,E)_{u_2}$ if and only if  the pairing
$(u_1-u_2,v_\rho) \leq 0$. Furthermore one observes that the image only depends
on the class of the weight $u$ in the quotient lattice $M_\rho := M/M^\rho$,
where $M^\rho$ denotes the intersection of $M$ with the vector space
perpendicular to the ray $\rho$. Since $M_\rho \cong \mathbb{Z}$ we denote the
image of $\Gamma(U_\rho,E)_u$ in $E_0$ by $E^\rho(i)$ with $i = (u,v_\rho)$.
Each ray $\rho \in{} \Sigma$ thus gives rise to an increasing filtration
$\{E^\rho(i)\}$ of $E_0$. Since $E_0$ is finite dimensional there is only a
finite set of integers $i$ for which a jump occurs, i.e., $E^\rho(i)$ strictly
contains $E^\rho(i-1)$. At all other steps the filtration remains constant.
Apart from that, each open affine subset $U_\sigma$ for $\sigma \in{} \Sigma$
induces a direct sum decomposition of $E_0 = \oplus_{u \in{}
M_\sigma}E^\sigma_u$ such that $E^\rho(i) = \sum_{(u,v_\rho) \leq i}
E^\sigma_u$ for each $\rho \in{} \sigma$ and $i \in{} \mathbb{Z}$. Observe that
the lattice $M_\sigma$ is defined analogously to the lattice $M_\rho$, i.e., it
is the quotient lattice $M/M^\sigma$ where $M^\sigma$ denotes the intersection
of $M$ with the vector space perpendicular to the cone $\sigma$."

With the notation and conventions introduced above it is now possible to state
the fundamental theorem of Klyachko which completely describes toric vector
bundles in linear algebraic terms:

The category of toric vector bundles on the toric variety $X$ is equivalent to
the category of finite dimensional $k$-vector spaces $E_0$ with collections of
increasing filtrations $\{E^{\rho}(i)| i \in{} \mathbb{Z}\}$, indexed by the
rays of $\Sigma$, satisfying the following compatibility condition: For each
cone $\sigma \in{} \Sigma$ there is a decomposition $E_0 = \oplus_{u \in{}
M_\sigma} E_u$ such that $E^{\rho}(i) = \sum_{(u,v_\rho) \leq i} E_u$ for every
ray $\rho \in{} \sigma$ and every $i \in{} \mathbb{Z}$.

"In contrast to the implementation of Kaneyama's description this one works for
every toric variety $X$ i.e., there are no restrictions on the fan $\Sigma$.
For each ray $\rho$ of the fan $\Sigma$ there are two matrices comprising the
necessary filtration data. The first one is  an invertible matrix $A(\rho)
\in{} $ GL("k,see QQ (Macaulay2Doc),") whose columns contain a basis of
the vector space $E_0$ which is associated to the filtration corresponding to
the ray $\rho$. The second one is a ",TT "1 x k"," integer matrix, the so
called filtration matrix. It determines at which step an element of the basis
given in the first matrix actually contributes to a certain subspace in the
filtration, i.e., if the j-th entry of the filtration matrix is i then the j-th
basis vector appears at the i-th step in the filtration. Hence $E^{\rho}(i)$ is
generated by all basis vectors listed in $A(\rho)$ whose corresponding entry in
the filtration matrix is less or equal to $E_0$."

"To link up to the description of Kaneyama we will also discuss the example of
the cotangent bundle $\mathbf{\Omega}_X$ of $X = \mathbb{P}^2$. Recall that $X$
can be given by the complete fan with rays $\rho_1 = (1,0)$, $\rho_2 = (0,1)$,
and $\rho_3 = (-1,-1)$. There are three maximal cones, namely $\sigma_1$
spanned by $\rho_1,\rho_2$,  $\sigma_2$ spanned by $\rho_2,\rho_3$, and
$\sigma_3$ spanned by $\rho_3,\rho_1$. Each of them corresponds to a torus
invariant affine chart $U_{\sigma_i}$. It follows that the $k[\sigma_1^v \cap
M]$-module $\Gamma(U_{\sigma_1},\Omega_X)$ is generated by $dx :=
d(x^{[1,0]})$, and $dy := d(x^{[0,1]})$, and analogously for the remaining
charts. We now fix a basis of $\Omega_0$ by evaluating the sections $dx,dy$ at
the unit $t_0$. This gives rise to filtrations $\Omega^\rho(i)$. We only
consider the example $\rho = \rho_3$. The filtrations for the two other rays
can be found by analogous calculations. Now, $k[U_{\rho_3}] =
k[x^{-1},x^{-1}y,xy^{-1}]$. Then, $\Gamma(U_{\rho_3},\Omega_X)$ is generated as
a $k[U_{\rho_3}]$-module by $-x^{-2}dx, -x^{-2}ydx + x^{-1}dy$. Thus,
$\Gamma(U_{\rho_3},\Omega_X)_{[1,0]} = 0$,
$\Gamma(U_{\rho_3},\Omega_X)_{[0,0]}$ is generated by $xy^{-1}(-x^{-2}ydx +
x^{-1}dy)$, and $\Gamma(U_{\rho_3},\Omega_X)_{[-1,0]}$ is two-dimensional.
Since $[1,0], [0,0]$, and $[-1,0]$ pair with $v_{\rho_3}=(-1,-1)$ to
respectively $-1, 0$, and $1$, the filtration $\Omega^{\rho_3}(i)$ jumps at $1$
and $0$ with corresponding basis vectors $(0,-1)$ and $(-1,1)$. Since
$\Omega_X$ already is a vector bundle we do not have to check the compatibility
conditions."

An instance of class ToricVectorBundleKlyachko, when displayed or printed,
gives an overview of the characteristics of the bundle:
+-----------------------------------------------+
|i1 : E = cotangentBundle(projectiveSpaceFan 2) |
|                                               |
|o1 = {dimension of the variety => 2 }          |
|      number of affine charts => 3             |
|      number of rays => 3                      |
|      rank of the vector bundle => 2           |
|                                               |
|o1 : ToricVectorBundleKlyachko                 |
+-----------------------------------------------+

To see all relevant details of a bundle use details. The data
described above are stored in a single hash table. In the example from above,
the keys are the rays of the fan, and each of them comes with a base matrix and
a filtration matrix:
+----------------------------------------------+
|i2 : details E                                |
|                                              |
|o2 = HashTable{| -1 | => (| 0  -1 |, | 1 0 |)}|
|               | -1 |     | -1 1  |           |
|               | 0 | => (| 0 1 |, | 1 0 |)    |
|               | 1 |     | 1 0 |              |
|               | 1 | => (| 1 0 |, | 1 0 |)    |
|               | 0 |     | 0 1 |              |
|                                              |
|o2 : HashTable                                |
+----------------------------------------------+

See also
========

  * ToricVectorBundleKaneyama -- the class of
    all toric vector bundles in Kaneyama's description
  * ToricVectorBundle -- the class of all toric
    vector bundles

Functions and methods returning a vector bundle on a toric variety (Klyachko's description) :
=============================================================================================

  * addBase -- changing the basis matrices of a toric vector
    bundle in Klyachko's description
  * addFiltration -- changing the filtration matrices of
    a toric vector bundle in Klyachko's description
  * randomDeformation --  a random deformation of a
    given toric vector bundle
  * twist --  twists a toric vector bundle with a line bundle

Methods that use a vector bundle on a toric variety (Klyachko's description) :
==============================================================================

  * "addBase(ToricVectorBundleKlyachko,List)" -- see addBase, --
    changing the basis matrices of a toric vector bundle in Klyachko's
    description
  * "addFiltration(ToricVectorBundleKlyachko,List)" -- see addFiltration,
    -- changing the filtration matrices of a toric vector bundle
    in Klyachko's description
  * "areIsomorphic(ToricVectorBundleKlyachko,ToricVectorBundleKlyachko)" -- see
    areIsomorphic, -- checks if two vector bundles are
    isomorphic
  * "base(ToricVectorBundleKlyachko)" -- see base, --  the basis
    matrices for the rays
  * cokernel(ToricVectorBundleKlyachko,Matrix)
    --  the cokernel of a
    morphism to a vector bundle
  * "existsDecomposition(ToricVectorBundleKlyachko,List)" -- see
    existsDecomposition, --  checks if a list of matrices
    of weight vectors for each maximal cone admits a decomposition
  * "filtration(ToricVectorBundleKlyachko)" -- see filtration,
    --  the filtration matrices of the vector bundle
  * "findWeights(ToricVectorBundleKlyachko)" -- see findWeights,
    --  finds the possible weight vectors for the maximal cones
  * image(ToricVectorBundleKlyachko,Matrix)
    --  the image of a vector
    bundle under a morphism
  * "isGeneral(ToricVectorBundleKlyachko)" -- see isGeneral,
    --  checks whether a toric vector bundle is general
  * "isomorphism(ToricVectorBundleKlyachko,ToricVectorBundleKlyachko)" -- see
    isomorphism, --  the isomorphism if the two bundles are
    isomorphic
  * kernel(ToricVectorBundleKlyachko,Matrix)
    --  the kernel of a
    morphism to a vector bundle
  * net(ToricVectorBundleKlyachko),
    -- displays characteristics of a toric vector bundle in Klyachko's
    description
  * "randomDeformation(ToricVectorBundleKlyachko,ZZ)" -- see
    randomDeformation, --  a random deformation of a given
    toric vector bundle
  * "randomDeformation(ToricVectorBundleKlyachko,ZZ,ZZ)" -- see
    randomDeformation, --  a random deformation of a given
    toric vector bundle
  * "twist(ToricVectorBundleKlyachko,List)" -- see twist, --
    twists a toric vector bundle with a line bundle

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

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

twist --  twists a toric vector bundle with a line bundle
*********************************************************

Synopsis
========

  * Usage:
        E1 = twist(E,L)
  * Inputs:
      * E, a vector bundle on a toric variety (Klyachko's description),
      * L, a list (Macaulay2Doc),
  * Outputs:
      * E1, a vector bundle on a toric variety (Klyachko's description),

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

twist takes a toric vector bundle $E$ in Klyachko's description and a list of
integers L. The list must contain one entry for each ray of the underlying fan.
Then it computes the twist of the vector bundle by the line bundle given by
these integers (see weilToCartier).
+-------------------------------------------------+
|i1 : E = tangentBundle hirzebruchFan 2           |
|                                                 |
|o1 = {dimension of the variety => 2 }            |
|      number of affine charts => 4               |
|      number of rays => 4                        |
|      rank of the vector bundle => 2             |
|                                                 |
|o1 : ToricVectorBundleKlyachko                   |
+-------------------------------------------------+
|i2 : L = {1,-2,3,-4}                             |
|                                                 |
|o2 = {1, -2, 3, -4}                              |
|                                                 |
|o2 : List                                        |
+-------------------------------------------------+
|i3 : E1 = twist(E,L)                             |
|                                                 |
|o3 = {dimension of the variety => 2 }            |
|      number of affine charts => 4               |
|      number of rays => 4                        |
|      rank of the vector bundle => 2             |
|                                                 |
|o3 : ToricVectorBundleKlyachko                   |
+-------------------------------------------------+
|i4 : details E1                                  |
|                                                 |
|o4 = HashTable{| -1 | => (| -1 1/2 |, | -4 -3 |)}|
|               | 2  |     | 2  0   |             |
|               | 0  | => (| 0  1 |, | -2 -1 |)   |
|               | -1 |     | -1 0 |               |
|               | 0 | => (| 0 1 |, | 1 2 |)       |
|               | 1 |     | 1 0 |                 |
|               | 1 | => (| 1 0 |, | 3 4 |)       |
|               | 0 |     | 0 1 |                 |
|                                                 |
|o4 : HashTable                                   |
+-------------------------------------------------+

See also
========

  * weilToCartier --  the line bundle given by a Cartier
    divisor
  * cartierIndex --  the Cartier index of a Weil divisor
  * details --  the details of a toric vector bundle

Ways to use twist :
===================

  * "twist(ToricVectorBundleKlyachko,List)"

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

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

weilToCartier --  the line bundle given by a Cartier divisor
************************************************************

Synopsis
========

  * Usage:
        E = weilToCartier(L,F)
  * Inputs:
      * L, a list (Macaulay2Doc),
      * F, an instance of the type Fan (OldPolyhedra), a pure and
        full dimensional fan
  * Optional inputs (Macaulay2Doc),:
      * Type
  * Outputs:
      * E, a vector bundle on a toric variety (Kaneyama's description),
        or a vector bundle on a toric variety (Klyachko's description),

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

L must a list of weights, exactly one for each ray of the fan. Then the list of
weights for each ray describes a Weil divisor on the toric variety. If the Weil
divisor defined by these weights defines in fact a Cartier divisor, then
weilToCartier computes the toric vector bundle associated to the Cartier
divisor.

If no further options are given then the resulting bundle will be in Klyachko's
description:
+-----------------------------------------+
|i1 : F = hirzebruchFan 3                 |
|                                         |
|o1 = {ambient dimension => 2         }   |
|      number of generating cones => 4    |
|      number of rays => 4                |
|      top dimension of the cones => 2    |
|                                         |
|o1 : Fan                                 |
+-----------------------------------------+
|i2 : E =weilToCartier({1,-3,4,-2},F)     |
|                                         |
|o2 = {dimension of the variety => 2 }    |
|      number of affine charts => 4       |
|      number of rays => 4                |
|      rank of the vector bundle => 1     |
|                                         |
|o2 : ToricVectorBundleKlyachko           |
+-----------------------------------------+
|i3 : details E                           |
|                                         |
|o3 = HashTable{| -1 | => (| 1 |, | -4 |)}|
|               | 3  |                    |
|               | 0  | => (| 1 |, | -1 |) |
|               | -1 |                    |
|               | 0 | => (| 1 |, | 3 |)   |
|               | 1 |                     |
|               | 1 | => (| 1 |, | 2 |)   |
|               | 0 |                     |
|                                         |
|o3 : HashTable                           |
+-----------------------------------------+

If the option "Type" => "Kaneyama" is given then the resulting bundle will be
in Kaneyama's description:
+---------------------------------------------------------------------+
|i4 : F = hirzebruchFan 3                                             |
|                                                                     |
|o4 = {ambient dimension => 2         }                               |
|      number of generating cones => 4                                |
|      number of rays => 4                                            |
|      top dimension of the cones => 2                                |
|                                                                     |
|o4 : Fan                                                             |
+---------------------------------------------------------------------+
|i5 : E =weilToCartier({1,-3,4,-2},F,"Type" => "Kaneyama")            |
|                                                                     |
|o5 = {dimension of the variety => 2 }                                |
|      number of affine charts => 4                                   |
|      rank of the vector bundle => 1                                 |
|                                                                     |
|o5 : ToricVectorBundleKaneyama                                       |
+---------------------------------------------------------------------+
|i6 : details E                                                       |
|                                                                     |
|o6 = (HashTable{0 => (| 0 -1 |, | 13 |)}, HashTable{(0, 1) => | 1 |})|
|                      | 1 3  |  | 3  |              (0, 2) => | 1 |  |
|                1 => (| 0  -1 |, | 7 |)             (1, 3) => | 1 |  |
|                      | -1 3  |  | 1 |              (2, 3) => | 1 |  |
|                2 => (| 1 0 |, | 2 |)                                |
|                      | 0 1 |  | 3 |                                 |
|                3 => (| 1 0  |, | 2 |)                               |
|                      | 0 -1 |  | 1 |                                |
|                                                                     |
|o6 : Sequence                                                        |
+---------------------------------------------------------------------+

See also
========

  * cartierIndex --  the Cartier index of a Weil divisor

Ways to use weilToCartier :
===========================

  * "weilToCartier(List,Fan)"

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

The object weilToCartier, is a method function with options (Macaulay2Doc).