This is Schubert2.info, produced by Macaulay2, version 1.24.11

Schubert2 -- computation in intersection theory
***********************************************

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

This package supports computation in intersection theory on smooth projective
varieties.  An abstract variety, is not given by
equations.  Instead, one gives its graded intersection ring of algebraic cycle
classes modulo numerical equivalence (tensored with the rational numbers or
perhaps with some algebra over the rational numbers), its dimension, a method
for counting the number of points in a cycle class of dimension zero
(integration), and the Chern class of its tangent bundle (if known).  The
intersection ring is represented as a Macaulay2 ring (Macaulay2Doc),
and its elements are Macaulay2 ring elements (Macaulay2Doc).

An abstract sheaf, on an abstract variety is represented
by an object of class AbstractSheaf, that contains the
total Chern character of the sheaf.  It should be thought of as an element of
the Grothendieck ring of the variety tensored with the rational numbers, which,
by the Grothendieck-Riemann-Roch theorem, is isomorphic to the intersection
ring; the isomorphism is provided by the Chern character.

An abstract variety map, is a map between abstract
varieties: the information encoded is the pull-back and push-forward maps
between the corresponding intersection rings.  If necessary, the push-forward
map is computed automatically from multiplication and integrals.

One may start with a base variety whose intersection ring contains variables of
degree 0 that can represent unknown integers in formulas, along with variables
of positive degree that can be used as Chern classes of generic abstract
sheaves.

This package is inspired by schubert (see http://stromme.uib.no/home/schubert/
), which was written by Sheldon Katz (see http://www.math.uiuc.edu/~katz/ ) and
Stein A. Strømme (see http://stromme.uib.no/ ).

The theory behind the computations of intersection rings of flag bundles has
been made rigorous in the paper Computations in intersection rings of flag
bundles by Grayson, Seceleanu, and Stillman: see arXiv:1205.4190 (see
http://arxiv.org/abs/1205.4190 ).  The paper also treats the case of isotropic
flag bundles, with the corresponding algorithms appearing here for the first
time.

Authors
=======

  * Daniel R. Grayson (see http://www.math.uiuc.edu/~dan/ ) <dan@math.uiuc.edu>
  * Michael E. Stillman (see
    http://www.math.cornell.edu/People/Faculty/stillman.html )
    <mike@math.cornell.edu>
  * Stein A. Strømme (see http://stromme.uib.no/home/ ) <stromme@math.uib.no>
  * David Eisenbud (see http://www.msri.org/~de/ ) <de@msri.org>
  * Charley Crissman (see http://math.berkeley.edu/~charleyc/ )
    <charleyc@math.berkeley.edu>

Version
=======

This documentation describes version 0.7 of Schubert2.

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

The source code from which this documentation is derived is in the file
Schubert2.m2 (see common/share/Macaulay2/Schubert2.m2 ). The auxiliary files
accompanying it are in the directory Schubert2/ (see
common/share/Macaulay2/Schubert2/ ).

Exports
=======

  * Types
      * AbstractSheaf -- the class of all abstract
        sheaves
      * AbstractVariety -- the class of all abstract
        varieties
      * AbstractVarietyMap -- the class of all
        abstract variety maps
      * ChernClassVariable -- the class of all Chern
        class variables
      * ChernClassVariableTable -- the class of
        all Chern class variable tables
      * Correspondence -- the class of all
        correspondences
      * FlagBundle -- the class of all flag bundles
      * IncidenceCorrespondence -- the class of
        all incidence correspondences
  * Functions and commands
      * abstractProjectiveSpace -- make a
        projective space
      * abstractProjectiveSpace' -- make a
        projective space
      * "abstractSheaf" -- see
        abstractSheaf(AbstractVariety,RingElement),
        -- make an abstract
        sheaf
      * "abstractVariety" -- see abstractVariety(ZZ,Ring),
        -- make an abstract variety
      * abstractVarietyMap -- make an abstract
        variety morphism
      * adams -- compute Adams operations
      * base -- make an abstract variety from nothing, equipped
        with some parameters and some bundles
      * blowup -- blow up an abstract variety along a subvariety
      * bundles -- get the list of tautological line bundles on
        a flag bundle
      * ch -- Chern character of an abstract sheaf
      * chern -- compute Chern classes of a sheaf
      * cotangentBundle -- get the cotangent bundle
      * "ctop" -- see ctop(AbstractSheaf), --
        the top Chern class of an abstract sheaf
      * "degeneracyLocus" -- see
        degeneracyLocus(ZZ,AbstractSheaf,AbstractSheaf),
      * "degeneracyLocus2" -- see
        degeneracyLocus2(ZZ,AbstractSheaf,AbstractSheaf),
      * exceptionalDivisor -- get the exceptional
        divisor of a blowup
      * extensionAlgebra -- extend a graded algebra by
        a graded module
      * flagBundle -- make a flag bundle
      * incidenceCorrespondence -- build
        containment correspondence between two Grassmannians
      * inclusion -- build the freest possible inclusion map
      * integral -- compute an integral (push forward a cycle
        to the base)
      * intermediates
      * "intersectionRing" -- see intersectionRing(AbstractVariety),
        -- get the intersection ring of
        an abstract variety
      * "kernelBundle" -- see
        kernelBundle(ZZ,AbstractSheaf,AbstractSheaf),
      * projectiveBundle -- make a projective bundle
        from an abstract sheaf
      * projectiveBundle' -- make a projective bundle
        from an abstract sheaf
      * schubertCycle -- compute Schubert Cycles on a
        Grassmannian, Fulton-style
      * schubertCycle' -- compute Schubert Cycles on a
        Grassmannian, Grothendieck-style
      * schubertRing -- get the Schubert ring of a
        Grassmannian
      * "schur" -- see schur(List,AbstractSheaf),
        -- apply a Schur functor to an
        abstract sheaf
      * "sectionClass" -- see sectionClass(AbstractVarietyMap),
        -- get the class of the image of
        a section of a map of abstract varieties
      * "sectionZeroLocus" -- see sectionZeroLocus(AbstractSheaf),
      * segre -- compute Segre classes of a sheaf
      * tangentBundle -- get the tangent bundle
      * tautologicalLineBundle -- get the
        tautological line bundle of a flag bundle or abstract variety
      * todd -- compute the Todd class of an abstract sheaf,
        variety, map
      * toSchubertBasis -- express cycles on a
        Grassmannian in terms of the Schubert basis
  * Methods
      * - AbstractSheaf -- negation of an abstract
        sheaf
      * "abstractProjectiveSpace(ZZ)" -- see abstractProjectiveSpace,
        -- make a projective space
      * "abstractProjectiveSpace(ZZ,AbstractVariety)" -- see
        abstractProjectiveSpace, -- make a projective
        space
      * "abstractProjectiveSpace'(ZZ)" -- see abstractProjectiveSpace',
        -- make a projective space
      * "abstractProjectiveSpace'(ZZ,AbstractVariety)" -- see
        abstractProjectiveSpace', -- make a
        projective space
      * AbstractSheaf * AbstractSheaf,
        -- (tensor) product of two abstract sheaves
      * "AbstractSheaf * QQ" -- see AbstractSheaf * AbstractSheaf,
        -- (tensor) product of two abstract
        sheaves
      * "AbstractSheaf * RingElement" -- see AbstractSheaf * AbstractSheaf,
        -- (tensor) product of
        two abstract sheaves
      * "AbstractSheaf * ZZ" -- see AbstractSheaf * AbstractSheaf,
        -- (tensor) product of two abstract
        sheaves
      * "AbstractSheaf ** AbstractSheaf" -- see AbstractSheaf * AbstractSheaf,
        -- (tensor) product of
        two abstract sheaves
      * "QQ * AbstractSheaf" -- see AbstractSheaf * AbstractSheaf,
        -- (tensor) product of two abstract
        sheaves
      * "RingElement * AbstractSheaf" -- see AbstractSheaf * AbstractSheaf,
        -- (tensor) product of
        two abstract sheaves
      * "ZZ * AbstractSheaf" -- see AbstractSheaf * AbstractSheaf,
        -- (tensor) product of two abstract
        sheaves
      * AbstractSheaf + AbstractSheaf, --
        (direct) sum of two abstract sheaves
      * "AbstractSheaf + QQ" -- see AbstractSheaf + AbstractSheaf,
        -- (direct) sum of two abstract sheaves
      * "AbstractSheaf + RingElement" -- see AbstractSheaf + AbstractSheaf,
        -- (direct) sum of two
        abstract sheaves
      * "AbstractSheaf + ZZ" -- see AbstractSheaf + AbstractSheaf,
        -- (direct) sum of two abstract sheaves
      * "AbstractSheaf ++ AbstractSheaf" -- see AbstractSheaf + AbstractSheaf,
        -- (direct) sum of two
        abstract sheaves
      * "AbstractSheaf ++ QQ" -- see AbstractSheaf + AbstractSheaf,
        -- (direct) sum of two abstract sheaves
      * "AbstractSheaf ++ RingElement" -- see AbstractSheaf + AbstractSheaf,
        -- (direct) sum of two
        abstract sheaves
      * "AbstractSheaf ++ ZZ" -- see AbstractSheaf + AbstractSheaf,
        -- (direct) sum of two abstract sheaves
      * "QQ + AbstractSheaf" -- see AbstractSheaf + AbstractSheaf,
        -- (direct) sum of two abstract sheaves
      * "QQ ++ AbstractSheaf" -- see AbstractSheaf + AbstractSheaf,
        -- (direct) sum of two abstract sheaves
      * "RingElement + AbstractSheaf" -- see AbstractSheaf + AbstractSheaf,
        -- (direct) sum of two
        abstract sheaves
      * "RingElement ++ AbstractSheaf" -- see AbstractSheaf + AbstractSheaf,
        -- (direct) sum of two
        abstract sheaves
      * "ZZ + AbstractSheaf" -- see AbstractSheaf + AbstractSheaf,
        -- (direct) sum of two abstract sheaves
      * "ZZ ++ AbstractSheaf" -- see AbstractSheaf + AbstractSheaf,
        -- (direct) sum of two abstract sheaves
      * AbstractSheaf - AbstractSheaf, --
        difference of two abstract sheaves
      * "AbstractSheaf - QQ" -- see AbstractSheaf - AbstractSheaf,
        -- difference of two abstract sheaves
      * "AbstractSheaf - RingElement" -- see AbstractSheaf - AbstractSheaf,
        -- difference of two
        abstract sheaves
      * "AbstractSheaf - ZZ" -- see AbstractSheaf - AbstractSheaf,
        -- difference of two abstract sheaves
      * "QQ - AbstractSheaf" -- see AbstractSheaf - AbstractSheaf,
        -- difference of two abstract sheaves
      * "RingElement - AbstractSheaf" -- see AbstractSheaf - AbstractSheaf,
        -- difference of two
        abstract sheaves
      * "ZZ - AbstractSheaf" -- see AbstractSheaf - AbstractSheaf,
        -- difference of two abstract sheaves
      * AbstractSheaf ^ ZZ -- power of an abstract
        sheaf
      * "AbstractSheaf ^** QQ" -- see AbstractSheaf ^** RingElement,
        -- tensor power of an abstract sheaf
      * AbstractSheaf ^** RingElement,
        -- tensor power of an abstract sheaf
      * "AbstractSheaf ^** ZZ" -- see AbstractSheaf ^** RingElement,
        -- tensor power of an abstract sheaf
      * "AbstractSheaf QQ" -- see AbstractSheaf RingElement,
        -- twist by a divisor class
      * AbstractSheaf RingElement -- twist by
        a divisor class
      * "AbstractSheaf ZZ" -- see AbstractSheaf RingElement,
        -- twist by a divisor class
      * "abstractSheaf(AbstractVariety)" -- see
        abstractSheaf(AbstractVariety,RingElement),
        -- make an abstract
        sheaf
      * "abstractSheaf(AbstractVariety,QQ)" -- see
        abstractSheaf(AbstractVariety,RingElement),
        -- make an abstract
        sheaf
      * abstractSheaf(AbstractVariety,RingElement)
        -- make an abstract
        sheaf
      * "abstractSheaf(AbstractVariety,ZZ)" -- see
        abstractSheaf(AbstractVariety,RingElement),
        -- make an abstract
        sheaf
      * AbstractVariety / AbstractVariety
        -- get a structure map
      * abstractVariety(ZZ,Ring) -- make
        an abstract variety
      * "abstractVarietyMap(AbstractVariety,AbstractVariety,MethodFunction,
        MethodFunction)" -- see abstractVarietyMap,
        -- make an abstract variety morphism
      * "abstractVarietyMap(AbstractVariety,AbstractVariety,RingMap,
        MethodFunction)" -- see abstractVarietyMap,
        -- make an abstract variety morphism
      * AbstractVarietyMap * AbstractVarietyMap
        -- composition of maps of abstract varieties
      * AbstractVarietyMap ^* -- pull back
        operator associated to a map of varieties
      * AbstractVarietyMap _* -- push forward
        operator associated to a map of varieties
      * adams(ZZ,AbstractSheaf), --
        compute Adams operations
      * adams(ZZ,RingElement) -- compute
        Adams operations
      * "base(Sequence)" -- see base, -- make an abstract variety
        from nothing, equipped with some parameters and some bundles
      * "base(Thing)" -- see base, -- make an abstract variety from
        nothing, equipped with some parameters and some bundles
      * "blowup(AbstractVarietyMap)" -- see blowup, -- blow up an
        abstract variety along a subvariety
      * "bundles(FlagBundle)" -- see bundles, -- get the list of
        tautological line bundles on a flag bundle
      * ch(AbstractSheaf) -- total Chern
        character of an abstract sheaf
      * ch(ZZ,AbstractSheaf) -- the i-th
        Chern character of an abstract sheaf
      * chern(AbstractSheaf) -- compute the
        total Chern class of a sheaf
      * chern(ZZ,AbstractSheaf), --
        compute a Chern class of a sheaf
      * chern(ZZ,ChernClassVariableTable)
        -- get value of a Chern class
        variable
      * chern(ZZ,Symbol) -- make a Chern class
        symbol
      * chern(ZZ,ZZ,AbstractSheaf),
        -- compute several Chern classes of an abstract sheaf
      * ChernClassVariable .. ChernClassVariable
        -- generate a sequence of Chern class
        variables
      * ChernClassVariable <- Thing, --
        assignment to a Chern class variable
      * chi(AbstractSheaf) -- compute the Euler
        characteristic of an abstract sheaf
      * Correspondence * Correspondence
        -- composition of correspondences
      * Correspondence ^* -- pullback along a
        correspondence
      * Correspondence _* -- pushforward along a
        correspondence
      * "cotangentBundle(AbstractVariety)" -- see cotangentBundle,
        -- get the cotangent bundle
      * "cotangentBundle(AbstractVarietyMap)" -- see cotangentBundle,
        -- get the cotangent bundle
      * ctop(AbstractSheaf) -- the top Chern
        class of an abstract sheaf
      * degeneracyLocus(ZZ,AbstractSheaf,AbstractSheaf)
      * degeneracyLocus2(ZZ,AbstractSheaf,AbstractSheaf)
      * determinant(AbstractSheaf), --
        determinant of an abstract sheaf
      * dim(AbstractVariety) -- the dimension
        of an abstract variety
      * dim(AbstractVarietyMap) -- the
        dimension of an abstract variety
      * dual(AbstractSheaf) -- the dual of an
        abstract sheaf
      * euler(AbstractVariety)
      * "exceptionalDivisor(AbstractVariety)" -- see exceptionalDivisor,
        -- get the exceptional divisor of a blowup
      * "extensionAlgebra(RingMap,RingElement)" -- see extensionAlgebra,
        -- extend a graded algebra by a graded module
      * exteriorPower(AbstractSheaf),
        -- alternating sum of exterior powers
      * exteriorPower(ZZ,AbstractSheaf)
      * "flagBundle(List)" -- see flagBundle, -- make a flag
        bundle
      * "flagBundle(List,AbstractSheaf)" -- see flagBundle,
        -- make a flag bundle
      * "flagBundle(List,AbstractVariety)" -- see flagBundle,
        -- make a flag bundle
      * "flagBundle(List,ZZ)" -- see flagBundle, -- make a
        flag bundle
      * Hom(AbstractSheaf,AbstractSheaf)
        -- Hom between abstract sheaves
      * "incidenceCorrespondence(FlagBundle,FlagBundle)" -- see
        incidenceCorrespondence, -- build containment
        correspondence between two Grassmannians
      * incidenceCorrespondence(List),
        -- build containment correspondence between two Grassmannians
      * incidenceCorrespondence(List,AbstractSheaf)
        -- build containment
        correspondence between two Grassmannians
      * "inclusion(RingMap)" -- see inclusion, -- build the
        freest possible inclusion map
      * "intermediates(IncidenceCorrespondence)" -- see intermediates,
      * intersectionRing(AbstractVariety)
        -- get the intersection ring of
        an abstract variety
      * kernelBundle(ZZ,AbstractSheaf,AbstractSheaf)
      * map(FlagBundle,AbstractVariety,AbstractSheaf)
        -- maps to
        projective bundles
      * "map(FlagBundle,AbstractVariety,List)" -- see
        map(FlagBundle,AbstractVarietyMap,List),
        -- make a map from an
        abstract variety to a flag bundle
      * map(FlagBundle,AbstractVarietyMap,List)
        -- make a map from an
        abstract variety to a flag bundle
      * map(FlagBundle,FlagBundle), --
        forgetful maps of flag varieties
      * OO _ AbstractVariety -- the structure
        sheaf of an abstract variety
      * "projectiveBundle(AbstractSheaf)" -- see projectiveBundle,
        -- make a projective bundle from an abstract sheaf
      * "projectiveBundle(ZZ)" -- see projectiveBundle,
        -- make a projective bundle from an abstract sheaf
      * "projectiveBundle(ZZ,AbstractVariety)" -- see projectiveBundle,
        -- make a projective bundle from an abstract sheaf
      * "projectiveBundle'(AbstractSheaf)" -- see projectiveBundle',
        -- make a projective bundle from an abstract sheaf
      * "projectiveBundle'(ZZ)" -- see projectiveBundle',
        -- make a projective bundle from an abstract sheaf
      * "projectiveBundle'(ZZ,AbstractVariety)" -- see projectiveBundle',
        -- make a projective bundle from an abstract sheaf
      * rank(AbstractSheaf)
      * Ring _ ChernClassVariable -- get a
        ring generator corresponding to a Chern class variable
      * "schubertCycle(List,FlagBundle)" -- see schubertCycle,
        -- compute Schubert Cycles on a Grassmannian,
        Fulton-style
      * "schubertCycle(Sequence,FlagBundle)" -- see schubertCycle,
        -- compute Schubert Cycles on a Grassmannian,
        Fulton-style
      * "FlagBundle _ List" -- see schubertCycle', --
        compute Schubert Cycles on a Grassmannian, Grothendieck-style
      * "FlagBundle _ Sequence" -- see schubertCycle', --
        compute Schubert Cycles on a Grassmannian, Grothendieck-style
      * "schubertCycle'(List,FlagBundle)" -- see schubertCycle',
        -- compute Schubert Cycles on a Grassmannian,
        Grothendieck-style
      * "schubertCycle'(Sequence,FlagBundle)" -- see schubertCycle',
        -- compute Schubert Cycles on a Grassmannian,
        Grothendieck-style
      * "schubertRing(FlagBundle)" -- see schubertRing, --
        get the Schubert ring of a Grassmannian
      * schur(List,AbstractSheaf), --
        apply a Schur functor to an abstract sheaf
      * sectionClass(AbstractVarietyMap)
        -- get the class of the image of
        a section of a map of abstract varieties
      * sectionZeroLocus(AbstractSheaf)
      * segre(AbstractSheaf) -- compute the
        total Segre class of a sheaf
      * segre(ZZ,AbstractSheaf), --
        compute a Segre class of a sheaf
      * source(AbstractVarietyMap), --
        the source of a map of abstract varieties
      * source(Correspondence) -- the source
        of a correspondence
      * symmetricPower(RingElement,AbstractSheaf)
        -- symmetric power of
        an abstract sheaf
      * "tangentBundle(AbstractVariety)" -- see tangentBundle,
        -- get the tangent bundle
      * "tangentBundle(AbstractVarietyMap)" -- see tangentBundle,
        -- get the tangent bundle
      * target(AbstractVarietyMap), --
        the target of a map of abstract varieties
      * target(Correspondence) -- the target
        of a correspondence
      * "tautologicalLineBundle(AbstractVariety)" -- see
        tautologicalLineBundle, -- get the tautological
        line bundle of a flag bundle or abstract variety
      * "tautologicalLineBundle(FlagBundle)" -- see
        tautologicalLineBundle, -- get the tautological
        line bundle of a flag bundle or abstract variety
      * "todd(AbstractSheaf)" -- see todd, -- compute the Todd
        class of an abstract sheaf, variety, map
      * "todd(AbstractVariety)" -- see todd, -- compute the Todd
        class of an abstract sheaf, variety, map
      * "todd(AbstractVarietyMap)" -- see todd, -- compute the Todd
        class of an abstract sheaf, variety, map
      * "toSchubertBasis(RingElement)" -- see toSchubertBasis,
        -- express cycles on a Grassmannian in terms of the
        Schubert basis
      * transpose(Correspondence), --
        reverse the direction of a correspondence
      * "transpose(IncidenceCorrespondence)" -- see
        transpose(Correspondence), -- reverse
        the direction of a correspondence
      * use(AbstractVariety) -- assign values
        to variables associated with a variety
      * value(ChernClassVariable) -- the
        value of a Chern class symbol
      * variety(AbstractSheaf) -- the
        variety of an abstract sheaf
  * Symbols
      * "VariableName" -- see abstractProjectiveSpace,
        -- make a projective space
      * "ChernCharacter" -- see
        abstractSheaf(AbstractVariety,RingElement),
        -- make an abstract
        sheaf
      * "ChernClass" -- see abstractSheaf(AbstractVariety,RingElement),
        -- make an abstract
        sheaf
      * "Rank" -- see abstractSheaf(AbstractVariety,RingElement),
        -- make an abstract
        sheaf
      * "DefaultIntegral" -- see abstractVariety(ZZ,Ring),
        -- make an abstract variety
      * "ReturnType" -- see abstractVariety(ZZ,Ring),
        -- make an abstract variety
      * "DefaultPullBack" -- see abstractVarietyMap,
        -- make an abstract variety morphism
      * "DefaultPushForward" -- see abstractVarietyMap,
        -- make an abstract variety morphism
      * "Bundle" -- see base, -- make an abstract variety from
        nothing, equipped with some parameters and some bundles
      * BundleRanks -- get the ranks of the tautological
        sheaves on a flag bundle
      * Bundles -- a symbol used internally as a key
      * "VariableNames" -- see flagBundle, -- make a flag
        bundle
      * "NormalClass" -- see inclusion, -- build the freest
        possible inclusion map
      * "SubDimension" -- see inclusion, -- build the freest
        possible inclusion map
      * "SubTangent" -- see inclusion, -- build the freest
        possible inclusion map
      * "SuperDimension" -- see inclusion, -- build the freest
        possible inclusion map
      * "SuperTangent" -- see inclusion, -- build the freest
        possible inclusion map
      * IntersectionRing -- a key used for storing the
        intersection ring in an abstract variety
      * Isotropic -- make an isotropic flag bundle
      * PullBack -- a symbol used internally as a key for
        storing the pull back map in an abstract variety map
      * QuotientBundles -- get the quotient bundles of
        the tautological filtration on a flag bundle
      * SchubertRing -- a symbol used internally as a key
      * SectionClass -- a symbol used internally as a key
      * StructureMap -- get the structure map of an
        abstract variety
      * SubBundles -- get the subbundles of the tautological
        filtration on a flag bundle
      * TangentBundle -- a symbol used internally as a
        key
      * TautologicalLineBundle -- a symbol used
        internally as a key
      * VarietyDimension -- get the dimension of a
        variety from its intersection ring
  * Other things
      * point -- the default base variety of dimension 0

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

The object Schubert2, is a package (Macaulay2Doc).

methods not involving something exported by this package:

Lines on hypersurfaces -- an example
************************************

There are d+1 conditions for a line to be contained in a general hypersurface
of degree d in $\PP^n$. The Grassmannian of lines in $\PP^n$ has dimension
2(n-1).  Therefore, when d+1 = 2(n-1), we should expect a finite number of
lines. Here is a way of computing the number using Schubert2.  In the case of
lines on a quintic hypersurface in $\PP^4$, this computation was done by
Hermann Schubert in 1879.

We will first illustrate the method by computing the number of lines on a cubic
surface in $\PP^3$.

We first construct an abstract variety, representing the
Grassmannian of lines in $\PP^3$ and then retrieve its tautological sub- and
quotient bundles.

+-------------------------------------------------+
|i1 : G = flagBundle({2,2}, VariableNames => {,c})|
|                                                 |
|o1 = G                                           |
|                                                 |
|o1 : a flag bundle with subquotient ranks {2:2}  |
+-------------------------------------------------+
|i2 : (S,Q) = bundles G                           |
|                                                 |
|o2 = (S, Q)                                      |
|                                                 |
|o2 : Sequence                                    |
+-------------------------------------------------+

Any cubic surface is given by a cubic form on $\PP^3$, that is, an element of
the third symmetric power of the space of linear forms, which is the trivial
rank 4 bundle on $\PP^3$.  Its image in the third symmetric power $Symm^3 Q$
of the quotient bundle $Q$ vanishes at those points of the Grassmannian that
correspond to lines on which the cubic form vanishes identically, that is,
lines contained in the cubic surface.  The class of this locus is the top Chern
class of this bundle.

+--------------------------------------------------------------------+
|i3 : B = symmetricPower(3,Q)                                        |
|                                                                    |
|o3 = B                                                              |
|                                                                    |
|o3 : an abstract sheaf of rank 4 on G                               |
+--------------------------------------------------------------------+
|i4 : c = chern(rank B,B)                                            |
|                                                                    |
|        2                                                           |
|o4 = 27c                                                            |
|        2                                                           |
|                                                                    |
|                         QQ[][H   ..H   , c ..c ]                   |
|                               1,1   1,2   1   2                    |
|o4 : ---------------------------------------------------------------|
|     (- H    - c , - H    - H   c  - c , - H   c  - H   c , -H   c )|
|         1,1    1     1,2    1,1 1    2     1,2 1    1,1 2    1,2 2 |
+--------------------------------------------------------------------+
|i5 : integral c                                                     |
|                                                                    |
|o5 = 27                                                             |
+--------------------------------------------------------------------+

We can do the same thing for any n, (with d = 2n-3) as follows:

+-----------------------------------------------------------------------------+
|i6 : f = n -> (                                                              |
|          G := flagBundle({n-1,2});                                          |
|          integral chern symmetricPower_(2*n-3) last bundles G               |
|          )                                                                  |
|                                                                             |
|o6 = f                                                                       |
|                                                                             |
|o6 : FunctionClosure                                                         |
+-----------------------------------------------------------------------------+
|i7 : for n from 2 to 10 list time f n                                        |
| -- used 0.00300034s (cpu); 0.00377272s (thread); 0s (gc)                    |
| -- used 0.00502396s (cpu); 0.00501413s (thread); 0s (gc)                    |
| -- used 0.00799263s (cpu); 0.00835124s (thread); 0s (gc)                    |
| -- used 0.0136282s (cpu); 0.0136631s (thread); 0s (gc)                      |
| -- used 0.0239499s (cpu); 0.0245234s (thread); 0s (gc)                      |
| -- used 0.0484009s (cpu); 0.0486307s (thread); 0s (gc)                      |
| -- used 0.0877423s (cpu); 0.0879417s (thread); 0s (gc)                      |
| -- used 0.141777s (cpu); 0.141806s (thread); 0s (gc)                        |
| -- used 0.240177s (cpu); 0.207591s (thread); 0s (gc)                        |
|                                                                             |
|o7 = {1, 27, 2875, 698005, 305093061, 210480374951, 210776836330775,         |
|     ------------------------------------------------------------------------|
|     289139638632755625, 520764738758073845321}                              |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+

Note: in characteristic zero, using Bertini's theorem, the numbers computed can
be proved to be equal to the actual numbers of distinct lines for general
hypersurfaces.  In $\PP^3$, every smooth cubic surface in characteristic zero
has exactly 27 lines. In higher dimensions there may be smooth hypersurfaces
for which the number of lines is different from the ``expected'' number that we
have computed above. For example, the Fermat quintic threefold has an infinite
number of lines on it.

See also
========

  * Conics on a quintic threefold -- an
    example

Conics on a quintic threefold -- an example
*******************************************

The number of conics (rational curves of degree 2) on a general quintic
hypersurface in $\PP^4$ was computed by S. Katz in 1985.  Here is how the
computation can be made with Schubert2.

Any conic in $\PP^4$ spans a unique plane, and the conics in a plane correspond
to the points of $\PP^5$.  Hence the space of conics in $\PP^4$ is a certain
$\PP^5$-bundle $X$ over the Grassmannian $G$ of planes in $\PP^4$.

+------------------------------------------------+
|i1 : G = flagBundle{2,3}                        |
|                                                |
|o1 = G                                          |
|                                                |
|o1 : a flag bundle with subquotient ranks {2..3}|
+------------------------------------------------+

We extract the rank 2 tautological subbundle $S$ and the rank 3 tautological
quotient bundle $Q$:

+----------------------+
|i2 : (S,Q) = bundles G|
|                      |
|o2 = (S, Q)           |
|                      |
|o2 : Sequence         |
+----------------------+

We form the bundle of quadratic forms on the variable planes:

+-------------------------------------+
|i3 : B = symmetricPower(2,Q)         |
|                                     |
|o3 = B                               |
|                                     |
|o3 : an abstract sheaf of rank 6 on G|
+-------------------------------------+

As a matter of convention, a projective bundle constructed by the function
projectiveBundle', in Schubert2 parametrizes rank 1
quotients of the sheaf provided.  The $\PP^5$-bundle of conics is given by
sublinebundles of $B$, or equivalently, by rank 1 quotients of the dual, $B^*$,
as in the following code:

+-----------------------------------------------------------+
|i4 : X = projectiveBundle'(dual B, VariableNames => {,{z}})|
|                                                           |
|o4 = X                                                     |
|                                                           |
|o4 : a flag bundle with subquotient ranks {5, 1}           |
+-----------------------------------------------------------+

The equation of the general quintic is a section of the fifth symmetric power
of the space of linear forms on $\PP^4$.  The induced equation on any given
conic is an element in the corresponding closed fiber of a certain vector
bundle $A$ of rank 11 on the parameter space $X$.  On any given plane $P$, and
for any conic $C$ in $P$, we get the following exact sequence: $$ 0 \to{}
H^0(O_P(3)) \to{} H^0(O_P(5)) \to{} H^0(O_C(5)) \to{} 0$$ As $C$ varies, these
sequences glue to a short exact sequence of bundles on $X$: $$ 0 \to{} Symm^3 Q
\otimes O(-z) \to{} Symm^5 Q \to{} A \to{} 0$$ We compute the class of $A$ in
the Grothendieck group:

+----------------------------------------------------------+
|i5 : A = symmetricPower_5 Q - symmetricPower_3 Q ** OO(-z)|
|                                                          |
|o5 = A                                                    |
|                                                          |
|o5 : an abstract sheaf of rank 11 on X                    |
+----------------------------------------------------------+

A given conic is contained in the quintic if and only if the equation of the
quintic vanishes identically on the conic.  Hence the class of the locus of
conics contained in the quintic is the top Chern class of $A$.  Hence the
number of them is the integral of this Chern class:

+---------------------+
|i6 : integral chern A|
|                     |
|o6 = 609250          |
+---------------------+

See also
========

  * Lines on hypersurfaces -- an example

The Horrocks-Mumford bundle -- an example
*****************************************

The Horrocks-Mumford bundle on projective 4-space can be constructed with the
following code.  We first produce a base point whose intersection ring contains
a variable named n, in terms of which we can compute the Hilbert polynomial.

+---------------------------------------+
|i1 : pt = base(n)                      |
|                                       |
|o1 = pt                                |
|                                       |
|o1 : an abstract variety of dimension 0|
+---------------------------------------+

Then we create the projective space of dimension 4 over the base point.

+------------------------------------------------+
|i2 : X = abstractProjectiveSpace'_4 pt          |
|                                                |
|o2 = X                                          |
|                                                |
|o2 : a flag bundle with subquotient ranks {4, 1}|
+------------------------------------------------+

Note that we use abstractProjectiveSpace', to
get Grothendieck-style notation.  This has the advantage that the first Chern
class of the tautological line bundle is assigned to the variable h:

+-------------------------------------------------------------------------+
|i3 : chern_1 OO_X(1)                                                     |
|                                                                         |
|o3 = h                                                                   |
|                                                                         |
|                             QQ[n][H   ..H   , h]                        |
|                                    1,1   1,4                            |
|o3 : --------------------------------------------------------------------|
|     (- H    - h, - H    - H   h, - H    - H   h, - H    - H   h, -H   h)|
|         1,1         1,2    1,1      1,3    1,2      1,4    1,3     1,4  |
+-------------------------------------------------------------------------+

Now we create an abstract sheaf of rank 2 with $1 + 5 h + 10 h^2$ as its total
Chern class:

+--------------------------------------------------------------------+
|i4 : F = abstractSheaf(X, Rank => 2, ChernClass => 1 + 5*h + 10*h^2)|
|                                                                    |
|o4 = F                                                              |
|                                                                    |
|o4 : an abstract sheaf of rank 2 on X                               |
+--------------------------------------------------------------------+

Alternatively, we can use the representation of the Horrocks-Mumford bundle as
the cohomology of the monad $$0 \rightarrow{} O_X(-1)^5 \rightarrow{}
\Omega_X^2(2)^2 \rightarrow{} O_X^5 \rightarrow{} 0$$ to produce a
construction:

+-----------------------------------------------------------------------------+
|i5 : F' = 2 * (exteriorPower_2 cotangentBundle X)(2) - 5 * OO_X(-1) - 5 *    |
|                                                                             |
|o5 = F'                                                                      |
|                                                                             |
|o5 : an abstract sheaf of rank 2 on X                                        |
|-----------------------------------------------------------------------------|
|OO_X                                                                         |
+-----------------------------------------------------------------------------+
|i6 : chern F'                                                                |
|                                                                             |
|               2                                                             |
|o6 = 1 - h + 4h                                                              |
|                                                                             |
|                             QQ[n][H   ..H   , h]                            |
|                                    1,1   1,4                                |
|o6 : --------------------------------------------------------------------    |
|     (- H    - h, - H    - H   h, - H    - H   h, - H    - H   h, -H   h)    |
|         1,1         1,2    1,1      1,3    1,2      1,4    1,3     1,4      |
+-----------------------------------------------------------------------------+
|i7 : rank F'                                                                 |
|                                                                             |
|o7 = 2                                                                       |
+-----------------------------------------------------------------------------+

Here is the relationship between the two bundles:

+----------------------+
|i8 : F === dual F'(-2)|
|                      |
|o8 = true             |
+----------------------+

Now we compute the Hilbert polynomial of $F$.  This computation makes use of
the Riemann-Roch Theorem.

+----------------------------------+
|i9 : chi F(n*h)                   |
|                                  |
|      1 4   5 3   125 2   125     |
|o9 = --n  + -n  + ---n  + ---n + 2|
|     12     3      12      6      |
|                                  |
|o9 : QQ[n]                        |
+----------------------------------+

Riemann-Roch on a curve
***********************

We follow Example 15.2.1 of Fulton's book, Intersection Theory.

+------------------------------------------------------------------+
|i1 : X = abstractVariety(1,QQ[r,s,e_1,f_1,D,K,Degrees=>{2:0,4:1}])|
|                                                                  |
|o1 = X                                                            |
|                                                                  |
|o1 : an abstract variety of dimension 1                           |
+------------------------------------------------------------------+
|i2 : X.TangentBundle = abstractSheaf(X,Rank=>1,ChernClass=>1-K)   |
|                                                                  |
|o2 = a sheaf                                                      |
|                                                                  |
|o2 : an abstract sheaf of rank 1 on X                             |
+------------------------------------------------------------------+
|i3 : chi OO_X                                                     |
|                                                                  |
|                1                                                 |
|o3 = integral(- -K)                                               |
|                2                                                 |
|                                                                  |
|o3 : Expression of class Adjacent                                 |
+------------------------------------------------------------------+
|i4 : chi OO(D)                                                    |
|                                                                  |
|                  1                                               |
|o4 = integral(D - -K)                                             |
|                  2                                               |
|                                                                  |
|o4 : Expression of class Adjacent                                 |
+------------------------------------------------------------------+
|i5 : E = abstractSheaf(X,Rank => r, ChernClass => 1+e_1)          |
|                                                                  |
|o5 = E                                                            |
|                                                                  |
|o5 : an abstract sheaf of rank r on X                             |
+------------------------------------------------------------------+
|i6 : F = abstractSheaf(X,Rank => s, ChernClass => 1+f_1)          |
|                                                                  |
|o6 = F                                                            |
|                                                                  |
|o6 : an abstract sheaf of rank s on X                             |
+------------------------------------------------------------------+
|i7 : chi Hom(E,F)                                                 |
|                                                                  |
|                1                                                 |
|o7 = integral(- -r*s*K - s*e  + r*f )                             |
|                2           1      1                              |
|                                                                  |
|o7 : Expression of class Adjacent                                 |
+------------------------------------------------------------------+

Riemann-Roch on a surface
*************************

We follow Example 15.2.2 of Fulton's book, Intersection Theory.

+----------------------------------------------------------------------+
|i1 : X = abstractVariety(2,QQ[r,D,d_1,K,c_2,d_2,Degrees=>{0,3:1,2:2}])|
|                                                                      |
|o1 = X                                                                |
|                                                                      |
|o1 : an abstract variety of dimension 2                               |
+----------------------------------------------------------------------+
|i2 : X.TangentBundle = abstractSheaf(X,Rank=>2,ChernClass=>1-K+c_2)   |
|                                                                      |
|o2 = a sheaf                                                          |
|                                                                      |
|o2 : an abstract sheaf of rank 2 on X                                 |
+----------------------------------------------------------------------+
|i3 : todd X                                                           |
|                                                                      |
|         1      1 2    1                                              |
|o3 = 1 - -K + (--K  + --c )                                           |
|         2     12     12 2                                            |
|                                                                      |
|o3 : QQ[r, D, d , K, c , d ]                                          |
|               1      2   2                                           |
+----------------------------------------------------------------------+
|i4 : chi OO_X                                                         |
|                                                                      |
|               1 2    1                                               |
|o4 = integral(--K  + --c )                                            |
|              12     12 2                                             |
|                                                                      |
|o4 : Expression of class Adjacent                                     |
+----------------------------------------------------------------------+
|i5 : E = abstractSheaf(X,Rank => r, ChernClass => 1+d_1+d_2)          |
|                                                                      |
|o5 = E                                                                |
|                                                                      |
|o5 : an abstract sheaf of rank r on X                                 |
+----------------------------------------------------------------------+
|i6 : chi ( E - rank E * OO_X )                                        |
|                                                                      |
|              1 2   1                                                 |
|o6 = integral(-d  - -d K - d )                                        |
|              2 1   2 1     2                                         |
|                                                                      |
|o6 : Expression of class Adjacent                                     |
+----------------------------------------------------------------------+
|i7 : chi ( OO(D) - OO_X )                                             |
|                                                                      |
|              1 2   1                                                 |
|o7 = integral(-D  - -D*K)                                             |
|              2     2                                                 |
|                                                                      |
|o7 : Expression of class Adjacent                                     |
+----------------------------------------------------------------------+
|i8 : chi OO_D                                                         |
|                                                                      |
|                1 2   1                                               |
|o8 = integral(- -D  - -D*K)                                           |
|                2     2                                               |
|                                                                      |
|o8 : Expression of class Adjacent                                     |
+----------------------------------------------------------------------+

We define a function to compute the arithmetic genus and use it to compute the
arithmetic genus of a curve on $X$ whose divisor class is $D$:

+--------------------------------+
|i9 : p_a = D -> 1 - chi OO_D;   |
+--------------------------------+
|i10 : p_a D                     |
|                                |
|                     1 2   1    |
|o10 = 1 - integral(- -D  - -D*K)|
|                     2     2    |
|                                |
|o10 : Expression of class Sum   |
+--------------------------------+

We we compute the arithmetic genus of a curve of degree $n$ in $\PP^2$:

+-------------------------------------------------+
|i11 : Y = abstractProjectiveSpace'_2 base n      |
|                                                 |
|o11 = Y                                          |
|                                                 |
|o11 : a flag bundle with subquotient ranks {2, 1}|
+-------------------------------------------------+
|i12 : factor p_a (n*h)                           |
|                                                 |
|                     1                           |
|o12 = (n - 2)(n - 1)(-)                          |
|                     2                           |
|                                                 |
|o12 : Expression of class Product                |
+-------------------------------------------------+

Here we compute the arithmetic genus of a curve on with $\PP^1 \times \PP^1$:

+-----------------------------------------------------------------------------+
|i13 : Z = abstractProjectiveSpace'_(1,VariableName => k)                     |
|                                                                             |
|o13 = Z                                                                      |
|                                                                             |
|o13 : a flag bundle with subquotient ranks {2:1}                             |
|-----------------------------------------------------------------------------|
|abstractProjectiveSpace'_1 base(m,n)                                         |
+-----------------------------------------------------------------------------+
|i14 : factor p_a (m*h + n*k)                                                 |
|                                                                             |
|o14 = (n - 1)(m - 1)                                                         |
|                                                                             |
|o14 : Expression of class Product                                            |
+-----------------------------------------------------------------------------+

In the code above we have used the notation f_(a,b) x as an abbreviation for
f(a,b,x), see Function _ Thing (Macaulay2Doc).

Riemann-Roch without denominators
*********************************

We display some of the universal polynomials described in Lemma 15.3 of
Fulton's book, Intersection Theory.

+-----------------------------------------------------------------------------+
|i1 : f = (n,d,e) -> (                                                        |
|         X = base(n,                                                         |
|              Bundle => (symbol D,d,chern_1 symbol D .. chern_d symbol D),   |
|              Bundle => (symbol E,e,chern_1 symbol E .. chern_e symbol E));  |
|         p := chern(exteriorPower dual D * E) - 1;                           |
|         assert( p % ctop D == 0 );                                          |
|         p // ctop D );                                                      |
+-----------------------------------------------------------------------------+
|i2 : n = 4;                                                                  |
+-----------------------------------------------------------------------------+
|i3 : for d from 1 to 3 do for e from 1 to 4 do << endl << "d="               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|--warning: clearing value of symbol D to allow access to Chern               |
|--warning: clearing value of symbol E to allow access to Chern               |
|                                                                             |
|                                         2                    2              |
|d=1 e=1 P(D,E) = 1 + (c D - c E) + ((c D)  - 2*c D*c E + (c E)               |
|                       1     1        1         1   1      1                 |
|                                                                             |
|                                             2                               |
|d=1 e=2 P(D,E) = 2 + (3*c D - c E) + (4*(c D)  - 3*c D*c E + (c              |
|                         1     1          1         1   1                    |
|                                                                             |
|                                              2                              |
|d=1 e=3 P(D,E) = 3 + (6*c D - c E) + (10*(c D)  - 4*c D*c E + (              |
|                         1     1           1         1   1                   |
|                                                                             |
|                                               2                             |
|d=1 e=4 P(D,E) = 4 + (10*c D - c E) + (20*(c D)  - 5*c D*c E +               |
|                          1     1           1         1   1                  |
|                                                                             |
|                                                 2                           |
|d=2 e=1 P(D,E) = - 1 + (- c D + 2*c E) + (- (c D)  + c D + 3*c               |
|                           1       1          1       2       1              |
|                                                                             |
|                                                     2                       |
|d=2 e=2 P(D,E) = - 2 + (- 2*c D + 2*c E) + (- 2*(c D)  + 3*c D               |
|                             1       1            1         2                |
|                                                                             |
|                                                     2                       |
|d=2 e=3 P(D,E) = - 3 + (- 3*c D + 2*c E) + (- 3*(c D)  + 6*c D               |
|                             1       1            1         2                |
|                                                                             |
|                                                     2                       |
|d=2 e=4 P(D,E) = - 4 + (- 4*c D + 2*c E) + (- 4*(c D)  + 10*c D              |
|                             1       1            1          2               |
|                                                                             |
|d=3 e=1 P(D,E) = 2 + (3*c D - 6*c E)                                         |
|                         1       1                                           |
|                                                                             |
|d=3 e=2 P(D,E) = 4 + (6*c D - 6*c E)                                         |
|                         1       1                                           |
|                                                                             |
|d=3 e=3 P(D,E) = 6 + (9*c D - 6*c E)                                         |
|                         1       1                                           |
|                                                                             |
|d=3 e=4 P(D,E) = 8 + (12*c D - 6*c E)                                        |
|                          1       1                                          |
|-----------------------------------------------------------------------------|
|<< d << " e=" << e << " P(D,E) = " << f(n,d,e) << endl                       |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|class variables based on it                                                  |
|                                                                             |
|          3          2                 2        3                            |
|) + ((c D)  - 3*(c D) c E + 3*c D*(c E)  - (c E) )                           |
|       1          1    1       1    1        1                               |
|                                                                             |
|   2                    3          2                 2        3              |
| E)  - 2*c E) + (5*(c D)  - 6*(c D) c E + 4*c D*(c E)  - (c E)  - 7*c D*c E +|
|1         2          1          1    1       1    1        1         1   2   |
|                                                                             |
|    2                     3           2                 2        3           |
|c E)  - 2*c E) + (15*(c D)  - 10*(c D) c E + 5*c D*(c E)  - (c E)  - 9*c D*c |
| 1         2           1           1    1       1    1        1         1   2|
|                                                                             |
|     2                     3           2                 2        3          |
|(c E)  - 2*c E) + (35*(c D)  - 15*(c D) c E + 6*c D*(c E)  - (c E)  - 11*c D*|
|  1         2           1           1    1       1    1        1          1  |
|                                                                             |
|               2                                                             |
|D*c E - 3*(c E) )                                                            |
|   1        1                                                                |
|                                                                             |
|                     2                                                       |
|+ 3*c D*c E - 3*(c E)  + 6*c E)                                              |
|     1   1        1         2                                                |
|                                                                             |
|                     2                                                       |
|+ 3*c D*c E - 3*(c E)  + 6*c E)                                              |
|     1   1        1         2                                                |
|                                                                             |
|                      2                                                      |
| + 3*c D*c E - 3*(c E)  + 6*c E)                                             |
|      1   1        1         2                                               |
|-----------------------------------------------------------------------------|
| 3*c E*c E)                                                                  |
|    1   2                                                                    |
|                                                                             |
|                                                                             |
|E + 3*c E*c E - 3*c E)                                                       |
|       1   2       3                                                         |
|                                                                             |
|                                                                             |
|c E + 3*c E*c E - 3*c E)                                                     |
| 2       1   2       3                                                       |
+-----------------------------------------------------------------------------+

A cubic fourfold containing a degree-5 del Pezzo surface -- an example
**********************************************************************

A smooth cubic fourfold Y containing a degree-5 del Pezzo surface X is known to
be rational, see for example S. L. Tregub's "Three constructions of rationality
of a four-dimensional cubic", 1984.  If H is the hyperplane class on Y, then 2H
- X is a linear series which gives a birational map from Y to \mathbb{P}^4.  We
will reproduce the numerical calculations which suggest (but do not prove) this
fact.  We start by building part of the Chow ring of Y:

+-----------------------------------------------------------------------------+
|i1 : p = base(r,s)                                                           |
|                                                                             |
|o1 = p                                                                       |
|                                                                             |
|o1 : an abstract variety of dimension 0                                      |
+-----------------------------------------------------------------------------+
|i2 : P5 = projectiveBundle(5,p)                                              |
|                                                                             |
|o2 = P5                                                                      |
|                                                                             |
|o2 : a flag bundle with subquotient ranks {1, 5}                             |
+-----------------------------------------------------------------------------+
|i3 : Y = sectionZeroLocus OO_P5(3) -- cubic fourfold                         |
|                                                                             |
|o3 = Y                                                                       |
|                                                                             |
|o3 : an abstract variety of dimension 4                                      |
+-----------------------------------------------------------------------------+
|i4 : x = chern(1,OO_Y(1)) -- hyperplane class                                |
|                                                                             |
|o4 = H                                                                       |
|      2,1                                                                    |
|                                                                             |
|                                            QQ[r..s][H   , H   ..H   ]       |
|                                                      1,1   2,1   2,5        |
|      -----------------------------------------------------------------------|
|      (- H    - H   , - H   H    - H   , - H   H    - H   , - H   H    - H   |
|          1,1    2,1     1,1 2,1    2,2     1,1 2,2    2,3     1,1 2,3    2,4|
|o4 : ------------------------------------------------------------------------|
|                                                       H                     |
|                                                        2,5                  |
|-----------------------------------------------------------------------------|
|-------------------------------                                              |
|, - H   H    - H   , -H   H   )                                              |
|     1,1 2,4    2,5    1,1 2,5                                               |
|--------------------------------                                             |
+-----------------------------------------------------------------------------+

We then build the Chow ring of the degree-5 del Pezzo:

+-----------------------------------------------------------------------------+
|i5 : S = intersectionRing p -- important that we use the same base ring      |
|                                                                             |
|o5 = S                                                                       |
|                                                                             |
|o5 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i6 : B1 = S[e_1..e_4,h, Join => false]                                       |
|                                                                             |
|o6 = B1                                                                      |
|                                                                             |
|o6 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i7 : I1 = (ideal vars B1)^3 -- relations imposed by dimension                |
|                                                                             |
|             3   2     2     2     2      2                            2     |
|o7 = ideal (e , e e , e e , e e , e h, e e , e e e , e e e , e e h, e e ,    |
|             1   1 2   1 3   1 4   1    1 2   1 2 3   1 2 4   1 2    1 3     |
|     ------------------------------------------------------------------------|
|                       2            2   3   2     2     2      2             |
|     e e e , e e h, e e , e e h, e h , e , e e , e e , e h, e e , e e e ,    |
|      1 3 4   1 3    1 4   1 4    1     2   2 3   2 4   2    2 3   2 3 4     |
|     ------------------------------------------------------------------------|
|               2            2   3   2     2      2            2   3   2      |
|     e e h, e e , e e h, e h , e , e e , e h, e e , e e h, e h , e , e h,    |
|      2 3    2 4   2 4    2     3   3 4   3    3 4   3 4    3     4   4      |
|     ------------------------------------------------------------------------|
|        2   3                                                                |
|     e h , h )                                                               |
|      4                                                                      |
|                                                                             |
|o7 : Ideal of B1                                                             |
+-----------------------------------------------------------------------------+
|i8 : I2 = ideal flatten (for i from 0 to 4 list (for j from i+1 to 4 list    |
|                                                                             |
|o8 = ideal (e e , e e , e e , e h, e e , e e , e h, e e , e h, e h)          |
|             1 2   1 3   1 4   1    2 3   2 4   2    3 4   3    4            |
|                                                                             |
|o8 : Ideal of B1                                                             |
|-----------------------------------------------------------------------------|
|(B1_i * B1_j))) -- relations imposed by non-intersection                     |
+-----------------------------------------------------------------------------+
|i9 : I3 = ideal for i from 1 to 4 list (e_i^2 + h^2) -- relations that make  |
|                                                                             |
|             2    2   2    2   2    2   2    2                               |
|o9 = ideal (e  + h , e  + h , e  + h , e  + h )                              |
|             1        2        3        4                                    |
|                                                                             |
|o9 : Ideal of B1                                                             |
|-----------------------------------------------------------------------------|
|each exceptional divisor a (-1)-curve                                        |
+-----------------------------------------------------------------------------+
|i10 : I = trim (I1 + I2 + I3)                                                |
|                                                                             |
|                                  2    2                     2    2          |
|o10 = ideal (e h, e h, e h, e h, e  + h , e e , e e , e e , e  + h , e e ,   |
|              4    3    2    1    4        3 4   2 4   1 4   3        2 3    |
|      -----------------------------------------------------------------------|
|             2    2         2    2                                           |
|      e e , e  + h , e e , e  + h )                                          |
|       1 3   2        1 2   1                                                |
|                                                                             |
|o10 : Ideal of B1                                                            |
+-----------------------------------------------------------------------------+
|i11 : B = B1/I                                                               |
|                                                                             |
|o11 = B                                                                      |
|                                                                             |
|o11 : QuotientRing                                                           |
+-----------------------------------------------------------------------------+
|i12 : integral B := b -> coefficient((B_4)^2, b)                             |
|                                                                             |
|o12 = FunctionClosure[stdio:12:14-12:42]                                     |
|                                                                             |
|o12 : FunctionClosure                                                        |
+-----------------------------------------------------------------------------+

We build the canonical class and tangent class of X:

+----------------------------------------+
|i13 : K = -(3*h - e_1 - e_2 - e_3 - e_4)|
|                                        |
|o13 = e  + e  + e  + e  - 3h            |
|       1    2    3    4                 |
|                                        |
|o13 : B                                 |
+----------------------------------------+
|i14 : tX = 1 - K + 7*h^2                |
|                                        |
|        2                               |
|o14 = 7h  - e  - e  - e  - e  + 3h + 1  |
|             1    2    3    4           |
|                                        |
|o14 : B                                 |
+----------------------------------------+

The pullback map from Y to X takes the hyperplane class to the anticanonical
class on X.  Because a projectiveBundle, has extra
generators, we end up also having to say where powers of the hyperplane class
map to:

+-----------------------------------------------------------------------------+
|i15 : A = intersectionRing Y                                                 |
|                                                                             |
|o15 = A                                                                      |
|                                                                             |
|o15 : QuotientRing                                                           |
+-----------------------------------------------------------------------------+
|i16 : f = map(B, A, {K, -K, K^2, -K^3, K^4, -K^5})                           |
|                                                                             |
|                                                                      2      |
|o16 = map (B, A, {e  + e  + e  + e  - 3h, - e  - e  - e  - e  + 3h, 5h , 0,  |
|                   1    2    3    4          1    2    3    4                |
|                                                                             |
|o16 : RingMap B <-- A                                                        |
|-----------------------------------------------------------------------------|
|0, 0, r, s})                                                                 |
+-----------------------------------------------------------------------------+

Now we build the inclusion, of X in Y, which assembles the
above information into a variety:

+----------------------------------------+
|i17 : i = inclusion(f,                  |
|         SubTangent => tX,              |
|         SubDimension => 2,             |
|         Base => p)                     |
|                                        |
|o17 = i                                 |
|                                        |
|o17 : a map to a variety from a variety |
+----------------------------------------+
|i18 : X = source i                      |
|                                        |
|o18 = X                                 |
|                                        |
|o18 : an abstract variety of dimension 2|
+----------------------------------------+
|i19 : Z = target i                      |
|                                        |
|o19 = Z                                 |
|                                        |
|o19 : an abstract variety of dimension 4|
+----------------------------------------+

We blow up this inclusion so that we can work with the linear series 2H - X as
a divisor.

+-------------------------------------------+
|i20 : (Ztilde, PN, PNmap, Zmap) = blowup(i)|
|                                           |
|o20 = (Ztilde, PN, PNmap, Zmap)            |
|                                           |
|o20 : Sequence                             |
+-------------------------------------------+

And now we calculate the Euler characteristic and degree of the line bundle 2H
- E on Ztilde.

+-------------------------------------------------------------------+
|i21 : AZtilde = intersectionRing Ztilde                            |
|                                                                   |
|o21 = AZtilde                                                      |
|                                                                   |
|o21 : QuotientRing                                                 |
+-------------------------------------------------------------------+
|i22 : exc = chern(1,exceptionalDivisor Ztilde) -- exceptional class|
|                                                                   |
|o22 = E                                                            |
|       0                                                           |
|                                                                   |
|o22 : AZtilde                                                      |
+-------------------------------------------------------------------+
|i23 : EBA = intersectionRing Z                                     |
|                                                                   |
|o23 = EBA                                                          |
|                                                                   |
|o23 : QuotientRing                                                 |
+-------------------------------------------------------------------+
|i24 : hyp = Zmap^* promote(x, EBA) -- hyperplane class of Ztilde   |
|                                                                   |
|o24 = H                                                            |
|       2,1                                                         |
|                                                                   |
|o24 : AZtilde                                                      |
+-------------------------------------------------------------------+
|i25 : L = OO_Ztilde(2*hyp - exc)                                   |
|                                                                   |
|o25 = L                                                            |
|                                                                   |
|o25 : an abstract sheaf of rank 1 on Ztilde                        |
+-------------------------------------------------------------------+
|i26 : chi L                                                        |
|                                                                   |
|o26 = 5                                                            |
|                                                                   |
|o26 : S                                                            |
+-------------------------------------------------------------------+
|i27 : integral ((chern(1,L))^4)                                    |
|                                                                   |
|o27 = 1                                                            |
|                                                                   |
|o27 : S                                                            |
+-------------------------------------------------------------------+

More generally, we can compute the Euler characteristic and degree of all line
bundles of the form rH + sE on Ztilde:

+-----------------------------------------------------------------------------+
|i28 : (r', s') = ((r_A, s_A) / (elt ->  promote(elt, EBA))) / Zmap^*         |
|                                                                             |
|o28 = (r, s)                                                                 |
|                                                                             |
|o28 : Sequence                                                               |
+-----------------------------------------------------------------------------+
|i29 : L = OO_Ztilde(r' * hyp + s' * exc)                                     |
|                                                                             |
|o29 = L                                                                      |
|                                                                             |
|o29 : an abstract sheaf of rank 1 on Ztilde                                  |
+-----------------------------------------------------------------------------+
|i30 : chi L                                                                  |
|                                                                             |
|      1 4   5 2 2   5   3    7 4   3 3   5 2    5   2   23 3   15 2   35     |
|o30 = -r  - -r s  - -r*s  - --s  + -r  + -r s - -r*s  - --s  + --r  + --r*s -|
|      8     4       3       24     4     4      4       12      8     12     |
|      -----------------------------------------------------------------------|
|       5 2   9    29                                                         |
|      --s  + -r + --s + 1                                                    |
|      24     4    12                                                         |
|                                                                             |
|o30 : S                                                                      |
+-----------------------------------------------------------------------------+
|i31 : integral ((chern(1,L))^4)                                              |
|                                                                             |
|        4      2 2        3     4                                            |
|o31 = 3r  - 30r s  - 40r*s  - 7s                                             |
|                                                                             |
|o31 : S                                                                      |
+-----------------------------------------------------------------------------+

Examples from Schubert, translated
**********************************

Here we present some examples from the Schubert documentation, translated line
by line into Schubert2 code.

Examples from Schubert's documentation

Other examples

Example from Schubert: Hilbert polynomial and Todd class of projective 3-space
******************************************************************************

> proj(3,h,all): factor(chi(o(n*h)));
                          1/6 (n + 3) (n + 2) (n + 1)
+------------------------------------------------+
|i1 : Ph = abstractProjectiveSpace'_3 base n     |
|                                                |
|o1 = Ph                                         |
|                                                |
|o1 : a flag bundle with subquotient ranks {3, 1}|
+------------------------------------------------+
|i2 : factor chi OO(n*h)                         |
|                                                |
|                           1                    |
|o2 = (n + 1)(n + 2)(n + 3)(-)                   |
|                           6                    |
|                                                |
|o2 : Expression of class Product                |
+------------------------------------------------+
> Ph[toddclass_];
                                           2  2    3  3
                         1 + 2 h t + 11/6 h  t  + h  t
+---------------------------------------------------------+
|i3 : todd Ph                                             |
|                                                         |
|              11 2    3                                  |
|o3 = 1 + 2h + --h  + h                                   |
|               6                                         |
|                                                         |
|                     QQ[n][H   ..H   , h]                |
|                            1,1   1,3                    |
|o3 : ----------------------------------------------------|
|     (- H    - h, - H    - H   h, - H    - H   h, -H   h)|
|         1,1         1,2    1,1      1,3    1,2     1,3  |
+---------------------------------------------------------+

Example from Schubert: Generation of formulas
*********************************************

> DIM:=4:
> A:=bundle(2,c):        # a bundle with Chern classes c1,c2 and rank 2
> B:=bundle(3,d):        # a bundle with Chern classes d1,d2,d3 and rank 3
+--------------------------------------------------+
|i1 : base(4, Bundle => (A,2,c), Bundle => (B,3,d))|
|                                                  |
|o1 = a variety                                    |
|                                                  |
|o1 : an abstract variety of dimension 4           |
+--------------------------------------------------+
> chern(A);
                                               2
                                1 + c1 t + c2 t
+-----------------------+
|i2 : chern A           |
|                       |
|o2 = 1 + c  + c        |
|          1    2       |
|                       |
|o2 : QQ[c ..c , d ..d ]|
|         1   2   1   3 |
+-----------------------+
> segre(B);
                             2        2      3                  3
               1 + d1 t + (d1  - d2) t  + (d1  - 2 d1 d2 + d3) t

                         4          2               2   4
                    + (d1  - 3 d2 d1  + 2 d1 d3 + d2 ) t
+-----------------------------------------------------------------------+
|i3 : segre B                                                           |
|                                                                       |
|                2           3                   4     2      2         |
|o3 = 1 + d  + (d  - d ) + (d  - 2d d  + d ) + (d  - 3d d  + d  + 2d d )|
|          1     1    2      1     1 2    3      1     1 2    2     1 3 |
|                                                                       |
|o3 : QQ[c ..c , d ..d ]                                                |
|         1   2   1   3                                                 |
+-----------------------------------------------------------------------+
> chern(A&*B);           # The Chern class of the tensor product
                         2                 2                 2
1 + (2 d1 + 3 c1) t + (d1  + 5 c1 d1 + 3 c1  + 2 d2 + 3 c2) t  +

                         3                           2                    2   3
  (6 c1 c2 + 2 d1 d2 + c1  + 2 d3 + 4 c1 d2 + 2 c1 d1  + 4 d1 c2 + 4 d1 c1 ) t

                                    2          2               2
   + (3 c1 d1 d2 + 6 d1 c1 c2 + 3 c2  + 3 c2 c1  + 2 d1 d3 + d2  + 3 c1 d3

            2       2        2   2        3   4
   + 2 c2 d1  + 3 c1  d2 + c1  d1  + d1 c1 ) t
+-----------------------------------------------------------------------------+
|i4 : chern(A**B)                                                             |
|                                                                             |
|                          2                  2            3             2    |
|o4 = 1 + (3c  + 2d ) + (3c  + 3c  + 5c d  + d  + 2d ) + (c  + 6c c  + 4c d  +|
|            1     1       1     2     1 1    1     2      1     1 2     1 1  |
|     ------------------------------------------------------------------------|
|                 2                             2       2    3                |
|     4c d  + 2c d  + 4c d  + 2d d  + 2d ) + (3c c  + 3c  + c d  + 6c c d  +  |
|       2 1     1 1     1 2     1 2     3       1 2     2    1 1     1 2 1    |
|     ------------------------------------------------------------------------|
|      2 2       2     2                2                                     |
|     c d  + 2c d  + 3c d  + 3c d d  + d  + 3c d  + 2d d )                    |
|      1 1     2 1     1 2     1 1 2    2     1 3     1 3                     |
|                                                                             |
|o4 : QQ[c ..c , d ..d ]                                                      |
|         1   2   1   3                                                       |
+-----------------------------------------------------------------------------+
> chern(3,symm(3,dual(A)));
                                     3
                               - 6 c1  - 30 c1 c2
+------------------------------------+
|i5 : chern_3 symmetricPower_3 dual A|
|                                    |
|         3                          |
|o5 = - 6c  - 30c c                  |
|         1      1 2                 |
|                                    |
|o5 : QQ[c ..c , d ..d ]             |
|         1   2   1   3              |
+------------------------------------+
> segre(2,Hom(wedge(2,A),wedge(2,B)));
                              2                 2
                          3 d1  - 8 c1 d1 + 6 c1  - d2
+-----------------------------------------------------+
|i6 : segre_2 Hom(exteriorPower_2 A,exteriorPower_2 B)|
|                                                     |
|       2             2                               |
|o6 = 6c  - 8c d  + 3d  - d                           |
|       1     1 1     1    2                          |
|                                                     |
|o6 : QQ[c ..c , d ..d ]                              |
|         1   2   1   3                               |
+-----------------------------------------------------+

Example from Schubert: Grassmannian of lines in P3
**************************************************

> grass(2,4,b,all):
+----------------------------------------------------------+
|i1 : Gb = flagBundle({2,2}, base n, VariableNames => {,b})|
|                                                          |
|o1 = Gb                                                   |
|                                                          |
|o1 : a flag bundle with subquotient ranks {2:2}           |
+----------------------------------------------------------+
|i2 : Qb = last bundles Gb                                 |
|                                                          |
|o2 = Qb                                                   |
|                                                          |
|o2 : an abstract sheaf of rank 2 on Gb                    |
+----------------------------------------------------------+
> chi(Gb,Symm(n,Qb));
                             2            3
                            n  + 1 + 1/6 n  + 11/6 n
+----------------------------+
|i3 : chi symmetricPower_n Qb|
|                            |
|     1 3    2   11          |
|o3 = -n  + n  + --n + 1     |
|     6           6          |
|                            |
|o3 : QQ[n]                  |
+----------------------------+
> chi(Gb,o(n*b1));
                           4        3    23   2
                     1/12 n  + 2/3 n  + ---- n  + 7/3 n + 1
                                         12
+-------------------------------+
|i4 : chi OO_Gb(n*b_1)          |
|                               |
|      1 4   2 3   23 2   7     |
|o4 = --n  + -n  + --n  + -n + 1|
|     12     3     12     3     |
|                               |
|o4 : QQ[n]                     |
+-------------------------------+
>
## This should be a quadric in P5:
>
> proj(5,H,all): chi(o(n*H)-o((n-2)*H));
                           4        3    23   2
                     1/12 n  + 2/3 n  + ---- n  + 7/3 n + 1
                                         12
+-----------------------------------------------------------------------------+
|i5 : P5 = abstractProjectiveSpace'(5,base n,VariableName=>H)                 |
|warning: clearing value of symbol H to allow access to subscripted variables |
|       : debug with expression   debug 204   or with command line option   --|
|                                                                             |
|o5 = P5                                                                      |
|                                                                             |
|o5 : a flag bundle with subquotient ranks {5, 1}                             |
|-----------------------------------------------------------------------------|
|based on it                                                                  |
|debug 204                                                                    |
+-----------------------------------------------------------------------------+
|i6 : chi(OO(n*H)-OO((n-2)*H))                                                |
|                                                                             |
|      1 4   2 3   23 2   7                                                   |
|o6 = --n  + -n  + --n  + -n + 1                                              |
|     12     3     12     3                                                   |
|                                                                             |
|o6 : QQ[n]                                                                   |
+-----------------------------------------------------------------------------+

Example from Schubert: Lines on a quintic threefold
***************************************************

# Lines on a quintic threefold.  This is the top Chern class of the
# 5th symmetric power of the universal quotient bundle on the Grassmannian
# of lines.
>
> grass(2,5,c):        # Lines in P^4.
+--------------------------------------------------+
|i1 : Gc = flagBundle({3,2}, VariableNames => {,c})|
|                                                  |
|o1 = Gc                                           |
|                                                  |
|o1 : a flag bundle with subquotient ranks {3, 2}  |
+--------------------------------------------------+
|i2 : (Sc,Qc) = bundles Gc                         |
|                                                  |
|o2 = (Sc, Qc)                                     |
|                                                  |
|o2 : Sequence                                     |
+--------------------------------------------------+
> B:=symm(5,Qc):       # Qc is the rank 2 quotient bundle, B its 5th
>                      # symmetric power.
+--------------------------------------+
|i3 : B = symmetricPower(5,Qc)         |
|                                      |
|o3 = B                                |
|                                      |
|o3 : an abstract sheaf of rank 6 on Gc|
+--------------------------------------+
> c6:=chern(rank(B),B):# the 6th Chern class of this rank 6 bundle.
+-----------------------------------------------------------------------------+
|i4 : c6 = chern(rank B,B)                                                    |
|                                                                             |
|          3                                                                  |
|o4 = 2875c                                                                   |
|          2                                                                  |
|                                                                             |
|                                      QQ[][H   ..H   , c ..c ]               |
|                                            1,1   1,3   1   2                |
|o4 : ------------------------------------------------------------------------|
|     (- H    - c , - H    - H   c  - c , - H    - H   c  - H   c , - H   c  -|
|         1,1    1     1,2    1,1 1    2     1,3    1,2 1    1,1 2     1,3 1  |
|-----------------------------------------------------------------------------|
|-----------------                                                            |
| H   c , -H   c )                                                            |
|  1,2 2    1,3 2                                                             |
+-----------------------------------------------------------------------------+
> integral(c6);
                                      2875
+----------------+
|i5 : integral c6|
|                |
|o5 = 2875       |
+----------------+

Example from Schubert: Conics on a quintic threefold
****************************************************

# Conics on a quintic threefold. This is the top Chern class of the
# quotient of the 5th symmetric power of the universal quotient on the
# Grassmannian of 2 planes in P^5 by the subbundle of quintic containing the
# tautological conic over the moduli space of conics.
>
> grass(3,5,c):         # 2-planes in P^4.
+--------------------------------------------------+
|i1 : Gc = flagBundle({2,3}, VariableNames => {,c})|
|                                                  |
|o1 = Gc                                           |
|                                                  |
|o1 : a flag bundle with subquotient ranks {2..3}  |
+--------------------------------------------------+
|i2 : (Sc,Qc) = bundles Gc                         |
|                                                  |
|o2 = (Sc, Qc)                                     |
|                                                  |
|o2 : Sequence                                     |
+--------------------------------------------------+
> B:=Symm(2,Qc):        # The bundle of conics in the 2-plane.
+--------------------------------------+
|i3 : B = symmetricPower(2,Qc)         |
|                                      |
|o3 = B                                |
|                                      |
|o3 : an abstract sheaf of rank 6 on Gc|
+--------------------------------------+
> Proj(X,dual(B),z):    # X is the projective bundle of all conics.
+-----------------------------------------------------------+
|i4 : X = projectiveBundle'(dual B, VariableNames => {,{z}})|
|                                                           |
|o4 = X                                                     |
|                                                           |
|o4 : a flag bundle with subquotient ranks {5, 1}           |
+-----------------------------------------------------------+
> A:=Symm(5,Qc)-Symm(3,Qc)&*o(-z):  # The rank 11 bundle of quintics
>                                   # restricted to the universal conic.
+------------------------------------------------------------+
|i5 : A = symmetricPower_5 Qc - symmetricPower_3 Qc ** OO(-z)|
|                                                            |
|o5 = A                                                      |
|                                                            |
|o5 : an abstract sheaf of rank 11 on X                      |
+------------------------------------------------------------+
> c11:=chern(rank(A),A):# its top Chern class.
+-----------------------------------------------------------------------------+
|i6 : c11 = chern(rank A, A)                                                  |
|                                                                             |
|            2 5                                                              |
|o6 = 609250c z                                                               |
|            3                                                                |
|                                                                             |
|                                                         QQ[][H   ..H   , c .|
|                                                               1,1   1,2   1 |
|                         ----------------------------------------------------|
|                         (- H    - c , - H    - H   c  - c , - H   c  - H   c|
|                             1,1    1     1,2    1,1 1    2     1,2 1    1,1 |
|o6 : ------------------------------------------------------------------------|
|                                           2                                 |
|     (- H    - z - 4c , - H    - H   z + 5c  + 5c , - H    - H   z - 15c c  -|
|         1,1         1     1,2    1,1      1     2     1,3    1,2       1 2  |
|-----------------------------------------------------------------------------|
|.c ]                                                                         |
|  3                                                                          |
|-----------------------------------[H   ..H   , z]                           |
|  - c , - H   c  - H   c , -H   c )  1,1   1,5                               |
|2    3     1,2 2    1,1 3    1,2 3                                           |
|----------------------------------------------------------------------       |
|                          2                                                  |
| 5c , - H    - H   z + 10c  + 20c c , - H    - H   z - 20c c , -H   z)       |
|   3     1,4    1,3       2      1 3     1,5    1,4       2 3    1,5         |
+-----------------------------------------------------------------------------+
> lowerstar(X,c11):     # push down to G(3,5).
+-----------------------------------------------------------------------------+
|i7 : X.StructureMap_* c11                                                    |
|                                                                             |
|            2                                                                |
|o7 = 609250c                                                                 |
|            3                                                                |
|                                                                             |
|                                     QQ[][H   ..H   , c ..c ]                |
|                                           1,1   1,2   1   3                 |
|o7 : ------------------------------------------------------------------------|
|     (- H    - c , - H    - H   c  - c , - H   c  - H   c  - c , - H   c  - H|
|         1,1    1     1,2    1,1 1    2     1,2 1    1,1 2    3     1,2 2    |
|-----------------------------------------------------------------------------|
|---------------                                                              |
|   c , -H   c )                                                              |
|1,1 3    1,2 3                                                               |
+-----------------------------------------------------------------------------+
> integral(Gc,");       # and integrate there.
                                     609250
+----------------+
|i8 : integral oo|
|                |
|o8 = 609250     |
+----------------+

Example from Schubert: Count the number of space conics intersecting 8 given lines
**********************************************************************************

> grass(3,4,d,all):
+----------------------------------------------------+
|i1 : Gd = flagBundle({1,3}, VariableNames => {,"d"})|
|                                                    |
|o1 = Gd                                             |
|                                                    |
|o1 : a flag bundle with subquotient ranks {1, 3}    |
+----------------------------------------------------+
|i2 : (Sd,Qd) = bundles Gd                           |
|                                                    |
|o2 = (Sd, Qd)                                       |
|                                                    |
|o2 : Sequence                                       |
+----------------------------------------------------+
> Proj(f,dual(symm(2,Qd)),e):
+-----------------------------------------------------------------------------+
|i3 : f = projectiveBundle'(dual symmetricPower_2 Qd, VariableNames => {,{e}})|
|                                                                             |
|o3 = f                                                                       |
|                                                                             |
|o3 : a flag bundle with subquotient ranks {5, 1}                             |
+-----------------------------------------------------------------------------+
> integral(Gd,lowerstar(f,(2*d1+e)^8));
                                       92
+--------------------------+
|i4 : integral (2*d1 + e)^8|
|                          |
|o4 = 92                   |
+--------------------------+

Example from Schubert: Euler characteristic of Horrocks-Mumford bundle
**********************************************************************

> proj(4,h,tang):            # need tangentbundle for chi
+-------------------------------------------------------------+
|i1 : X = abstractProjectiveSpace'(4,base n,VariableName => h)|
|                                                             |
|o1 = X                                                       |
|                                                             |
|o1 : a flag bundle with subquotient ranks {4, 1}             |
+-------------------------------------------------------------+
> F:=sheaf(2,[5*h,10*h^2]):  # defines the Horrocks-Mumford bundle
+--------------------------------------------------------------------+
|i2 : F = abstractSheaf(X, Rank => 2, ChernClass => 1 + 5*h + 10*h^2)|
|                                                                    |
|o2 = F                                                              |
|                                                                    |
|o2 : an abstract sheaf of rank 2 on X                               |
+--------------------------------------------------------------------+
> chi(F&*o(n*h));            # computes chi of its twists
                          4        3   125  2
                    1/12 n  + 5/3 n  + --- n  + 125/6 n + 2
                                        12
+----------------------------------+
|i3 : chi (F ** OO(n*h))           |
|                                  |
|      1 4   5 3   125 2   125     |
|o3 = --n  + -n  + ---n  + ---n + 2|
|     12     3      12      6      |
|                                  |
|o3 : QQ[n]                        |
+----------------------------------+

Example from Schubert: Riemann-Roch formulas
********************************************

# Line bundle O(D) on a threefold.
>
> variety(X,dim=3,tan=sheaf(3,[-K,c2,c3])): # traditionally, -K is
>                                           # used instead of c1
+---------------------------------------------------------------------------+
|i1 : X = abstractVariety(3,QQ[K,c_2,c_3, Degrees => {1..3}][D,Join=>false])|
|                                                                           |
|o1 = X                                                                     |
|                                                                           |
|o1 : an abstract variety of dimension 3                                    |
+---------------------------------------------------------------------------+
|i2 : X.TangentBundle = abstractSheaf(X,Rank=>3,ChernClass=>1-K+c_2+c_3)    |
|                                                                           |
|o2 = a sheaf                                                               |
|                                                                           |
|o2 : an abstract sheaf of rank 3 on X                                      |
+---------------------------------------------------------------------------+
> chi(o(D));
                        3          2          2
       integral(X, 1/6 D  - 1/4 K D  + (1/12 K  + 1/12 c2) D - 1/24 K c2)
+----------------------------------------------------+
|i3 : chi OO(D)                                      |
|                                                    |
|              1 3   1   2     1 2    1        1     |
|o3 = integral(-D  - -K*D  + (--K  + --c )D - --K*c )|
|              6     4        12     12 2     24   2 |
|                                                    |
|o3 : Expression of class Adjacent                   |
+----------------------------------------------------+

Example from Schubert: The number of elliptic cubics on a sextic 4-fold
***********************************************************************

We thank Rahul Pandharipande for this classic Schubert example.  See
Enumerative Geometry of Calabi-Yau 4-Folds (see
http://arxiv.org/abs/math/0702189 ).

> grass(3,6,c):
+--------------------------------------------------+
|i1 : Gc = flagBundle({3,3}, VariableNames => {,c})|
|                                                  |
|o1 = Gc                                           |
|                                                  |
|o1 : a flag bundle with subquotient ranks {2:3}   |
+--------------------------------------------------+
|i2 : (Sc,Qc) = bundles Gc                         |
|                                                  |
|o2 = (Sc, Qc)                                     |
|                                                  |
|o2 : Sequence                                     |
+--------------------------------------------------+
> B:=Symm(3,Qc):
+---------------------------------------+
|i3 : B = symmetricPower_3 Qc           |
|                                       |
|o3 = B                                 |
|                                       |
|o3 : an abstract sheaf of rank 10 on Gc|
+---------------------------------------+
> Proj(X,dual(B),z):
+-----------------------------------------------------------+
|i4 : X = projectiveBundle'(dual B, VariableNames => {,{z}})|
|                                                           |
|o4 = X                                                     |
|                                                           |
|o4 : a flag bundle with subquotient ranks {9, 1}           |
+-----------------------------------------------------------+
> A:=Symm(6,Qc)-Symm(3,Qc)&@o(-z):
+------------------------------------------------------------+
|i5 : A = symmetricPower_6 Qc - symmetricPower_3 Qc ** OO(-z)|
|                                                            |
|o5 = A                                                      |
|                                                            |
|o5 : an abstract sheaf of rank 18 on X                      |
+------------------------------------------------------------+
> c18:=chern(rank(A),A):
> lowerstar(X,c18):
> integral(Gc,%);
Ans =  2734099200
+---------------------+
|i6 : integral chern A|
|                     |
|o6 = 2734099200      |
+---------------------+

Ideas for future development
****************************

  * Introduce the notation F/S for the structure map from F to S, and extend it
    to towers of structure maps.  Then we could downplay StructureMap.
    We could also change tangentBundle F so it yields the
    relative tangent bundle over the immediate predecessor, and let
    tangentBundle(F/point) serve as the notation for the absolute tangent
    bundle (see tangentBundle).  We could also adopt the
    notation OO_(F/S)(n) for tautological sheaves.
  * compare logg and expp to the routines in Schubert, and try to speed them up
  * Maybe we should distinguish between cohomology and homology.
  * eliminate the generators from the intersection ring of a flag bundle that
    correspond to the Chern classes of the first tautological subquotient
    bundle
  * change the default names H_(i,j) for the Chern classes of the tautological
    subquotient bundles on a flag variety to chern_j E_i
  * make an easy way to specify maps from a variety to a flag bundle, by
    specifying where all (but one) of the tautological subquotients go
  * make it possible to call the toric package
  * add the blow up of a subvariety with known normal bundle and known
    restriction function
  * add a function that goes from the Hilbert series of a sheaf on projective
    space to the Chern class
  * add knowledge of the intersection ring of an abelian variety, in particular
    of the Jacobian of a curve
  * add knowledge of the tautological ring (as far as it's known!) of M_(g,n)
  * add excess intersection formula
  * add double (and multiple) point formula
  * add Bott's formula, useful for counting twisted cubics, as described in
    Schubert2/Stromme/

OO _ RingElement -- the abstract structure sheaf of a divisor class
*******************************************************************

Synopsis
========

  * Operator: _ (Macaulay2Doc),
  * Usage:
        OO_D
  * Inputs:
      * D, of degree 1, representing a divisor class on an abstract variety
  * Outputs:
      * the abstract sheaf $O_D$, defined as $1 - O(-D)$

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

+-------------------------------------------------------------------------+
|i1 : X = abstractProjectiveSpace' 4                                      |
|                                                                         |
|o1 = X                                                                   |
|                                                                         |
|o1 : a flag bundle with subquotient ranks {4, 1}                         |
+-------------------------------------------------------------------------+
|i2 : h                                                                   |
|                                                                         |
|o2 = h                                                                   |
|                                                                         |
|                              QQ[][H   ..H   , h]                        |
|                                    1,1   1,4                            |
|o2 : --------------------------------------------------------------------|
|     (- H    - h, - H    - H   h, - H    - H   h, - H    - H   h, -H   h)|
|         1,1         1,2    1,1      1,3    1,2      1,4    1,3     1,4  |
+-------------------------------------------------------------------------+
|i3 : F = OO_h                                                            |
|                                                                         |
|o3 = F                                                                   |
|                                                                         |
|o3 : an abstract sheaf of rank 0 on X                                    |
+-------------------------------------------------------------------------+
|i4 : chern F                                                             |
|                                                                         |
|              2    3    4                                                |
|o4 = 1 + h + h  + h  + h                                                 |
|                                                                         |
|                              QQ[][H   ..H   , h]                        |
|                                    1,1   1,4                            |
|o4 : --------------------------------------------------------------------|
|     (- H    - h, - H    - H   h, - H    - H   h, - H    - H   h, -H   h)|
|         1,1         1,2    1,1      1,3    1,2      1,4    1,3     1,4  |
+-------------------------------------------------------------------------+
|i5 : ch F                                                                |
|                                                                         |
|         1 2   1 3    1 4                                                |
|o5 = h - -h  + -h  - --h                                                 |
|         2     6     24                                                  |
|                                                                         |
|                              QQ[][H   ..H   , h]                        |
|                                    1,1   1,4                            |
|o5 : --------------------------------------------------------------------|
|     (- H    - h, - H    - H   h, - H    - H   h, - H    - H   h, -H   h)|
|         1,1         1,2    1,1      1,3    1,2      1,4    1,3     1,4  |
+-------------------------------------------------------------------------+

AbstractSheaf RingElement -- twist by a divisor class
*****************************************************

Synopsis
========

  * Operator: SPACE (Macaulay2Doc),
  * Usage:
        F(n)
  * Inputs:
      * F,
      * n, in (or promotable to) the intersection ring of the variety of $F$,
        homogeneous of degree 1 or 0
  * Outputs:
      * which depends on the degree of n. In the case where n has degree 0, the
        sheaf returned is the tensor product of F with the n-th (tensor) power
        of the tautological line bundle on the variety of F. In the case where
        n has degree 1, the sheaf returned is the tensor product of F with the
        line bundle whose first Chern class is n.

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

+------------------------------------------------+
|i1 : X = abstractProjectiveSpace' 4             |
|                                                |
|o1 = X                                          |
|                                                |
|o1 : a flag bundle with subquotient ranks {4, 1}|
+------------------------------------------------+
|i2 : OO_X(3)                                    |
|                                                |
|o2 = a sheaf                                    |
|                                                |
|o2 : an abstract sheaf of rank 1 on X           |
+------------------------------------------------+
|i3 : chi oo                                     |
|                                                |
|o3 = 35                                         |
+------------------------------------------------+
|i4 : pt = base n                                |
|                                                |
|o4 = pt                                         |
|                                                |
|o4 : an abstract variety of dimension 0         |
+------------------------------------------------+
|i5 : Y = abstractProjectiveSpace'(4,pt)         |
|                                                |
|o5 = Y                                          |
|                                                |
|o5 : a flag bundle with subquotient ranks {4, 1}|
+------------------------------------------------+
|i6 : OO_Y(n)                                    |
|                                                |
|o6 = a sheaf                                    |
|                                                |
|o6 : an abstract sheaf of rank 1 on Y           |
+------------------------------------------------+
|i7 : chi oo                                     |
|                                                |
|      1 4    5 3   35 2   25                    |
|o7 = --n  + --n  + --n  + --n + 1               |
|     24     12     24     12                    |
|                                                |
|o7 : QQ[n]                                      |
+------------------------------------------------+

The notation OO(n) is an abbreviation for OO_X(n), where X is the variety whose
intersection ring n is in.  By default, the first Chern class of the
tautological line bundle on a projective space or projective bundle is called
h, so we may use OO(h) as alternative notation for OO_Y(1):

+--------------------------------------+
|i8 : A = intersectionRing Y           |
|                                      |
|o8 = A                                |
|                                      |
|o8 : QuotientRing                     |
+--------------------------------------+
|i9 : chern OO_Y(1)                    |
|                                      |
|o9 = 1 + h                            |
|                                      |
|o9 : A                                |
+--------------------------------------+
|i10 : OO(h)                           |
|                                      |
|o10 = a sheaf                         |
|                                      |
|o10 : an abstract sheaf of rank 1 on Y|
+--------------------------------------+
|i11 : chern oo                        |
|                                      |
|o11 = 1 + h                           |
|                                      |
|o11 : A                               |
+--------------------------------------+

Caveat
======

Beware the low parsing precedence of the adjacency operator SPACE (Macaulay2Doc).

See also
========

  * tautologicalLineBundle -- get the
    tautological line bundle of a flag bundle or abstract variety

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

  * "AbstractSheaf QQ"
  * AbstractSheaf RingElement -- twist by a
    divisor class
  * "AbstractSheaf ZZ"

- AbstractSheaf -- negation of an abstract sheaf
************************************************

Synopsis
========

  * Operator: - (Macaulay2Doc),
  * Usage:
        -F
  * Inputs:
      * F,
  * Outputs:
      * the negation of F, as a virtual sheaf.

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

+------------------------------------------------+
|i1 : X = abstractProjectiveSpace 2              |
|                                                |
|o1 = X                                          |
|                                                |
|o1 : a flag bundle with subquotient ranks {1..2}|
+------------------------------------------------+
|i2 : - OO_X(1)                                  |
|                                                |
|o2 = a sheaf                                    |
|                                                |
|o2 : an abstract sheaf of rank -1 on X          |
+------------------------------------------------+
|i3 : chern oo                                   |
|                                                |
|o3 = 1 - H    + H                               |
|          2,1    2,2                            |
|                                                |
|               QQ[][h, H   ..H   ]              |
|                        2,1   2,2               |
|o3 : --------------------------------------     |
|     (- h - H   , - h*H    - H   , -h*H   )     |
|             2,1       2,1    2,2      2,2      |
+------------------------------------------------+

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

  * - AbstractSheaf -- negation of an abstract sheaf

abstractProjectiveSpace -- make a projective space
**************************************************

Synopsis
========

  * Usage:
        abstractProjectiveSpace n
        abstractProjectiveSpace(n, S)
        abstractProjectiveSpace_n S
  * Inputs:
      * n, an integer (Macaulay2Doc),
      * S, an abstract variety, if omitted, then
        point, is used for it
  * Optional inputs (Macaulay2Doc),:
      * VariableName => a symbol (Macaulay2Doc), default value
        "h", the symbol to use for the variable representing the first Chern
        class of the tautological line bundle on the resulting projective space
  * Outputs:
      * the projective space of rank 1 subbundles of the trivial bundle of rank
        $n+1$ on the base variety S.

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

Equivalent to flagBundle(\{1,n\},S,VariableNames=>\{h,\}).

+------------------------------------------------------------+
|i1 : P = abstractProjectiveSpace 3                          |
|                                                            |
|o1 = P                                                      |
|                                                            |
|o1 : a flag bundle with subquotient ranks {1, 3}            |
+------------------------------------------------------------+
|i2 : tangentBundle P                                        |
|                                                            |
|o2 = a sheaf                                                |
|                                                            |
|o2 : an abstract sheaf of rank 3 on P                       |
+------------------------------------------------------------+
|i3 : chern tangentBundle P                                  |
|                                                            |
|o3 = 1 + 4H    + 6H    + 4H                                 |
|           2,1     2,2     2,3                              |
|                                                            |
|                       QQ[][h, H   ..H   ]                  |
|                                2,1   2,3                   |
|o3 : -------------------------------------------------------|
|     (- h - H   , - h*H    - H   , - h*H    - H   , -h*H   )|
|             2,1       2,1    2,2       2,2    2,3      2,3 |
+------------------------------------------------------------+
|i4 : todd P                                                 |
|                                                            |
|                 11                                         |
|o4 = 1 + 2H    + --H    + H                                 |
|           2,1    6 2,2    2,3                              |
|                                                            |
|                       QQ[][h, H   ..H   ]                  |
|                                2,1   2,3                   |
|o4 : -------------------------------------------------------|
|     (- h - H   , - h*H    - H   , - h*H    - H   , -h*H   )|
|             2,1       2,1    2,2       2,2    2,3      2,3 |
+------------------------------------------------------------+
|i5 : chi OO_P(3)                                            |
|                                                            |
|o5 = 20                                                     |
+------------------------------------------------------------+

The name is quite long.  Here is one way to make it shorter

+------------------------------------------------+
|i6 : PP = abstractProjectiveSpace               |
|                                                |
|o6 = abstractProjectiveSpace                    |
|                                                |
|o6 : MethodFunctionWithOptions                  |
+------------------------------------------------+
|i7 : X = PP 4                                   |
|                                                |
|o7 = X                                          |
|                                                |
|o7 : a flag bundle with subquotient ranks {1, 4}|
+------------------------------------------------+

To compute the Hilbert polynomial of a sheaf on projective space, we work over
a base variety of dimension zero whose intersection ring contains a free
variable $n$, instead of working over point,:

+------------------------------------------------+
|i8 : pt = base n                                |
|                                                |
|o8 = pt                                         |
|                                                |
|o8 : an abstract variety of dimension 0         |
+------------------------------------------------+
|i9 : Q = abstractProjectiveSpace_4 pt           |
|                                                |
|o9 = Q                                          |
|                                                |
|o9 : a flag bundle with subquotient ranks {1, 4}|
+------------------------------------------------+
|i10 : chi OO_Q(n)                               |
|                                                |
|       1 4    5 3   35 2   25                   |
|o10 = --n  + --n  + --n  + --n + 1              |
|      24     12     24     12                   |
|                                                |
|o10 : QQ[n]                                     |
+------------------------------------------------+

The base variety may itself be a projective space:

+-----------------------------------------------------------------------------+
|i11 : S = abstractProjectiveSpace(4, VariableName => symbol h)               |
|                                                                             |
|o11 = S                                                                      |
|                                                                             |
|o11 : a flag bundle with subquotient ranks {1, 4}                            |
+-----------------------------------------------------------------------------+
|i12 : P = abstractProjectiveSpace(3, S, VariableName => H)                   |
|warning: clearing value of symbol H to allow access to subscripted variables |
|       : debug with expression   debug 204   or with command line option   --|
|warning: clearing value of symbol H to allow access to subscripted variables |
|       : debug with expression   debug 204   or with command line option   --|
|                                                                             |
|o12 = P                                                                      |
|                                                                             |
|o12 : a flag bundle with subquotient ranks {1, 3}                            |
|-----------------------------------------------------------------------------|
|based on it                                                                  |
|debug 204                                                                    |
|based on it                                                                  |
|debug 204                                                                    |
+-----------------------------------------------------------------------------+
|i13 : dim P                                                                  |
|                                                                             |
|o13 = 7                                                                      |
+-----------------------------------------------------------------------------+
|i14 : todd P                                                                 |
|                                                                             |
|                   5         11                   35                         |
|o14 = 1 + (2H    + -H   ) + (--H    + 5H   H    + --H   ) + (H    +          |
|             2,1   2 2,1      6 2,2     2,1 2,1   12 2,2      2,3            |
|      -----------------------------------------------------------------------|
|      55           35           25         5           385                   |
|      --H   H    + --H   H    + --H   ) + (-H   H    + ---H   H    +         |
|      12 2,1 2,2    6 2,2 2,1   12 2,3     2 2,1 2,3    72 2,2 2,2           |
|      -----------------------------------------------------------------------|
|      25                    35           275                                 |
|      --H   H    + H   ) + (--H   H    + ---H   H    + 2H   H   ) +          |
|       6 2,3 2,1    2,4     12 2,2 2,3    72 2,3 2,2     2,4 2,1             |
|      -----------------------------------------------------------------------|
|       25           11                                                       |
|      (--H   H    + --H   H   ) + H   H                                      |
|       12 2,3 2,3    6 2,4 2,2     2,4 2,3                                   |
|                                                                             |
|                                 QQ[][h, H   ..H   ]                         |
|                                          2,1   2,4                          |
|      -----------------------------------------------------------------------|
|      (- h - H   , - h*H    - H   , - h*H    - H   , - h*H    - H   , -h*H   |
|              2,1       2,1    2,2       2,2    2,3       2,3    2,4      2,4|
|o14 : -----------------------------------------------------------------------|
|                      (- H - H   , - H*H    - H   , - H*H    - H   , -H*H   )|
|                              2,1       2,1    2,2       2,2    2,3      2,3 |
|-----------------------------------------------------------------------------|
|-[H, H   ..H   ]                                                             |
|)     2,1   2,3                                                              |
|                                                                             |
|----------------                                                             |
+-----------------------------------------------------------------------------+

See also
========

  * abstractProjectiveSpace' -- make a
    projective space
  * projectiveBundle -- make a projective bundle from
    an abstract sheaf
  * flagBundle -- make a flag bundle
  * tangentBundle -- get the tangent bundle
  * todd -- compute the Todd class of an abstract sheaf, variety,
    map
  * chi (Macaulay2Doc)
  * base -- make an abstract variety from nothing, equipped with
    some parameters and some bundles
  * OO _ AbstractVariety (missing documentation)

Ways to use abstractProjectiveSpace:
====================================

  * "abstractProjectiveSpace(ZZ)"
  * "abstractProjectiveSpace(ZZ,AbstractVariety)"

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

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

abstractProjectiveSpace' -- make a projective space
***************************************************

Synopsis
========

  * Usage:
        abstractProjectiveSpace' n
        abstractProjectiveSpace'(n, S)
        abstractProjectiveSpace'_n S
  * Inputs:
      * n, an integer (Macaulay2Doc),
      * S, an abstract variety, if omitted, then
        point, is used for it
  * Optional inputs (Macaulay2Doc),:
      * VariableName => a symbol (Macaulay2Doc), default value
        "h", the symbol to use for the variable representing the first Chern
        class of the tautological line bundle on the resulting projective space
  * Outputs:
      * the projective space of rank 1 quotient bundles of the trivial bundle
        of rank $n+1$ on the base variety S.

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

+---------------------------------------------------------+
|i1 : P = abstractProjectiveSpace' 3                      |
|                                                         |
|o1 = P                                                   |
|                                                         |
|o1 : a flag bundle with subquotient ranks {3, 1}         |
+---------------------------------------------------------+
|i2 : tangentBundle P                                     |
|                                                         |
|o2 = a sheaf                                             |
|                                                         |
|o2 : an abstract sheaf of rank 3 on P                    |
+---------------------------------------------------------+
|i3 : chern tangentBundle P                               |
|                                                         |
|                2     3                                  |
|o3 = 1 + 4h + 6h  + 4h                                   |
|                                                         |
|                      QQ[][H   ..H   , h]                |
|                            1,1   1,3                    |
|o3 : ----------------------------------------------------|
|     (- H    - h, - H    - H   h, - H    - H   h, -H   h)|
|         1,1         1,2    1,1      1,3    1,2     1,3  |
+---------------------------------------------------------+
|i4 : todd P                                              |
|                                                         |
|              11 2    3                                  |
|o4 = 1 + 2h + --h  + h                                   |
|               6                                         |
|                                                         |
|                      QQ[][H   ..H   , h]                |
|                            1,1   1,3                    |
|o4 : ----------------------------------------------------|
|     (- H    - h, - H    - H   h, - H    - H   h, -H   h)|
|         1,1         1,2    1,1      1,3    1,2     1,3  |
+---------------------------------------------------------+
|i5 : chi OO_P(3)                                         |
|                                                         |
|o5 = 20                                                  |
+---------------------------------------------------------+

To compute the Hilbert polynomial of a sheaf on projective space, we work over
a base variety of dimension zero whose intersection ring contains a free
variable $n$, instead of working over point,:

+------------------------------------------------+
|i6 : pt = base n                                |
|                                                |
|o6 = pt                                         |
|                                                |
|o6 : an abstract variety of dimension 0         |
+------------------------------------------------+
|i7 : Q = abstractProjectiveSpace'_4 pt          |
|                                                |
|o7 = Q                                          |
|                                                |
|o7 : a flag bundle with subquotient ranks {4, 1}|
+------------------------------------------------+
|i8 : chi OO_Q(n)                                |
|                                                |
|      1 4    5 3   35 2   25                    |
|o8 = --n  + --n  + --n  + --n + 1               |
|     24     12     24     12                    |
|                                                |
|o8 : QQ[n]                                      |
+------------------------------------------------+

The base variety may itself be a projective space:

+-----------------------------------------------------------------------------+
|i9 : S = abstractProjectiveSpace'(4, VariableName => h)                      |
|                                                                             |
|o9 = S                                                                       |
|                                                                             |
|o9 : a flag bundle with subquotient ranks {4, 1}                             |
+-----------------------------------------------------------------------------+
|i10 : P = abstractProjectiveSpace'(3, S, VariableName => H)                  |
|warning: clearing value of symbol H to allow access to subscripted variables |
|       : debug with expression   debug 204   or with command line option   --|
|                                                                             |
|o10 = P                                                                      |
|                                                                             |
|o10 : a flag bundle with subquotient ranks {3, 1}                            |
|-----------------------------------------------------------------------------|
|based on it                                                                  |
|debug 204                                                                    |
+-----------------------------------------------------------------------------+
|i11 : dim P                                                                  |
|                                                                             |
|o11 = 7                                                                      |
+-----------------------------------------------------------------------------+
|i12 : todd P                                                                 |
|                                                                             |
|                5      11 2          35 2      3   55   2   35 2    25 3     |
|o12 = 1 + (2H + -h) + (--H  + 5h*H + --h ) + (H  + --h*H  + --h H + --h ) +  |
|                2       6            12            12        6      12       |
|      -----------------------------------------------------------------------|
|       5   3   385 2 2   25 3     4     35 2 3   275 3 2     4      25 3 3   |
|      (-h*H  + ---h H  + --h H + h ) + (--h H  + ---h H  + 2h H) + (--h H  + |
|       2        72        6             12        72                12       |
|      -----------------------------------------------------------------------|
|      11 4 2     4 3                                                         |
|      --h H ) + h H                                                          |
|       6                                                                     |
|                                                                             |
|                               QQ[][H   ..H   , h]                           |
|                                     1,1   1,4                               |
|      --------------------------------------------------------------------[H |
|      (- H    - h, - H    - H   h, - H    - H   h, - H    - H   h, -H   h)  1|
|          1,1         1,2    1,1      1,3    1,2      1,4    1,3     1,4     |
|o12 : -----------------------------------------------------------------------|
|                      (- H    - H, - H    - H   H, - H    - H   H, -H   H)   |
|                          1,1         1,2    1,1      1,3    1,2     1,3     |
|-----------------------------------------------------------------------------|
|  ..H   , H]                                                                 |
|,1   1,3                                                                     |
|                                                                             |
|------------                                                                 |
+-----------------------------------------------------------------------------+

See also
========

  * abstractProjectiveSpace -- make a
    projective space
  * projectiveBundle -- make a projective bundle from
    an abstract sheaf
  * flagBundle -- make a flag bundle
  * tangentBundle -- get the tangent bundle
  * todd -- compute the Todd class of an abstract sheaf, variety,
    map
  * chi (Macaulay2Doc)
  * base -- make an abstract variety from nothing, equipped with
    some parameters and some bundles
  * OO _ AbstractVariety (missing documentation)

Ways to use abstractProjectiveSpace':
=====================================

  * "abstractProjectiveSpace'(ZZ)"
  * "abstractProjectiveSpace'(ZZ,AbstractVariety)"

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

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

AbstractSheaf -- the class of all abstract sheaves
**************************************************

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

A virtual abstract sheaf over an abstract variety, $X$
is specified by its total Chern character.

Functions and methods returning an abstract sheaf:
==================================================

  * - AbstractSheaf -- negation of an abstract sheaf
  * AbstractSheaf * AbstractSheaf, --
    (tensor) product of two abstract sheaves
  * "AbstractSheaf * ZZ" -- see AbstractSheaf * AbstractSheaf,
    -- (tensor) product of two abstract
    sheaves
  * "AbstractSheaf ** AbstractSheaf" -- see AbstractSheaf * AbstractSheaf,
    -- (tensor) product of two
    abstract sheaves
  * "QQ * AbstractSheaf" -- see AbstractSheaf * AbstractSheaf,
    -- (tensor) product of two abstract
    sheaves
  * "ZZ * AbstractSheaf" -- see AbstractSheaf * AbstractSheaf,
    -- (tensor) product of two abstract
    sheaves
  * AbstractSheaf + AbstractSheaf, --
    (direct) sum of two abstract sheaves
  * "AbstractSheaf + QQ" -- see AbstractSheaf + AbstractSheaf,
    -- (direct) sum of two abstract sheaves
  * "AbstractSheaf + RingElement" -- see AbstractSheaf + AbstractSheaf,
    -- (direct) sum of two abstract sheaves
  * "AbstractSheaf + ZZ" -- see AbstractSheaf + AbstractSheaf,
    -- (direct) sum of two abstract sheaves
  * "AbstractSheaf ++ AbstractSheaf" -- see AbstractSheaf + AbstractSheaf,
    -- (direct) sum of two
    abstract sheaves
  * "AbstractSheaf ++ QQ" -- see AbstractSheaf + AbstractSheaf,
    -- (direct) sum of two abstract sheaves
  * "AbstractSheaf ++ RingElement" -- see AbstractSheaf + AbstractSheaf,
    -- (direct) sum of two abstract sheaves
  * "AbstractSheaf ++ ZZ" -- see AbstractSheaf + AbstractSheaf,
    -- (direct) sum of two abstract sheaves
  * "QQ + AbstractSheaf" -- see AbstractSheaf + AbstractSheaf,
    -- (direct) sum of two abstract sheaves
  * "QQ ++ AbstractSheaf" -- see AbstractSheaf + AbstractSheaf,
    -- (direct) sum of two abstract sheaves
  * "RingElement + AbstractSheaf" -- see AbstractSheaf + AbstractSheaf,
    -- (direct) sum of two abstract sheaves
  * "RingElement ++ AbstractSheaf" -- see AbstractSheaf + AbstractSheaf,
    -- (direct) sum of two abstract sheaves
  * "ZZ + AbstractSheaf" -- see AbstractSheaf + AbstractSheaf,
    -- (direct) sum of two abstract sheaves
  * "ZZ ++ AbstractSheaf" -- see AbstractSheaf + AbstractSheaf,
    -- (direct) sum of two abstract sheaves
  * AbstractSheaf - AbstractSheaf, --
    difference of two abstract sheaves
  * "AbstractSheaf - QQ" -- see AbstractSheaf - AbstractSheaf,
    -- difference of two abstract sheaves
  * "AbstractSheaf - RingElement" -- see AbstractSheaf - AbstractSheaf,
    -- difference of two abstract sheaves
  * "AbstractSheaf - ZZ" -- see AbstractSheaf - AbstractSheaf,
    -- difference of two abstract sheaves
  * "QQ - AbstractSheaf" -- see AbstractSheaf - AbstractSheaf,
    -- difference of two abstract sheaves
  * "RingElement - AbstractSheaf" -- see AbstractSheaf - AbstractSheaf,
    -- difference of two abstract sheaves
  * "ZZ - AbstractSheaf" -- see AbstractSheaf - AbstractSheaf,
    -- difference of two abstract sheaves
  * AbstractSheaf ^ ZZ -- power of an abstract sheaf
  * "AbstractSheaf ^** QQ" -- see AbstractSheaf ^** RingElement,
    -- tensor power of an abstract sheaf
  * AbstractSheaf ^** RingElement, --
    tensor power of an abstract sheaf
  * "AbstractSheaf ^** ZZ" -- see AbstractSheaf ^** RingElement,
    -- tensor power of an abstract sheaf
  * "AbstractSheaf QQ" -- see AbstractSheaf RingElement,
    -- twist by a divisor class
  * AbstractSheaf RingElement -- twist by a
    divisor class
  * "AbstractSheaf ZZ" -- see AbstractSheaf RingElement,
    -- twist by a divisor class
  * "OO RingElement" -- see AbstractSheaf RingElement,
    -- twist by a divisor class
  * "abstractSheaf" -- see abstractSheaf(AbstractVariety,RingElement),
    -- make an abstract sheaf
  * adams(ZZ,AbstractSheaf) -- compute
    Adams operations
  * cotangentBundle -- get the cotangent bundle
  * determinant(AbstractSheaf), --
    determinant of an abstract sheaf
  * dual(AbstractSheaf) -- the dual of an
    abstract sheaf
  * exteriorPower(AbstractSheaf), --
    alternating sum of exterior powers
  * exteriorPower(ZZ,AbstractSheaf)
  * Hom(AbstractSheaf,AbstractSheaf)
    -- Hom between abstract sheaves
  * OO _ AbstractVariety -- the structure sheaf
    of an abstract variety
  * OO _ RingElement -- the abstract structure sheaf
    of a divisor class
  * "schur" -- see schur(List,AbstractSheaf),
    -- apply a Schur functor to an abstract
    sheaf
  * symmetricPower(RingElement,AbstractSheaf)
    -- symmetric power of an
    abstract sheaf
  * tangentBundle -- get the tangent bundle

Methods that use an abstract sheaf:
===================================

  * "AbstractSheaf * QQ" -- see AbstractSheaf * AbstractSheaf,
    -- (tensor) product of two abstract
    sheaves
  * "AbstractSheaf * RingElement" -- see AbstractSheaf * AbstractSheaf,
    -- (tensor) product of two abstract
    sheaves
  * "RingElement * AbstractSheaf" -- see AbstractSheaf * AbstractSheaf,
    -- (tensor) product of two abstract
    sheaves
  * ch(AbstractSheaf) -- total Chern character of
    an abstract sheaf
  * ch(ZZ,AbstractSheaf) -- the i-th Chern
    character of an abstract sheaf
  * chern(AbstractSheaf) -- compute the total
    Chern class of a sheaf
  * chern(ZZ,AbstractSheaf) -- compute a
    Chern class of a sheaf
  * chern(ZZ,ZZ,AbstractSheaf), --
    compute several Chern classes of an abstract sheaf
  * chi(AbstractSheaf) -- compute the Euler
    characteristic of an abstract sheaf
  * ctop(AbstractSheaf) -- the top Chern class
    of an abstract sheaf
  * degeneracyLocus(ZZ,AbstractSheaf,AbstractSheaf)
  * degeneracyLocus2(ZZ,AbstractSheaf,AbstractSheaf)
  * "flagBundle(List,AbstractSheaf)" -- see flagBundle, --
    make a flag bundle
  * incidenceCorrespondence(List,AbstractSheaf)
    -- build containment
    correspondence between two Grassmannians
  * kernelBundle(ZZ,AbstractSheaf,AbstractSheaf)
  * map(FlagBundle,AbstractVariety,AbstractSheaf)
    -- maps to
    projective bundles
  * "projectiveBundle(AbstractSheaf)" -- see projectiveBundle,
    -- make a projective bundle from an abstract sheaf
  * "projectiveBundle'(AbstractSheaf)" -- see projectiveBundle',
    -- make a projective bundle from an abstract sheaf
  * rank(AbstractSheaf)
  * schur(List,AbstractSheaf) -- apply
    a Schur functor to an abstract sheaf
  * sectionZeroLocus(AbstractSheaf)
  * segre(AbstractSheaf) -- compute the total
    Segre class of a sheaf
  * segre(ZZ,AbstractSheaf) -- compute a
    Segre class of a sheaf
  * "todd(AbstractSheaf)" -- see todd, -- compute the Todd class of
    an abstract sheaf, variety, map
  * variety(AbstractSheaf) -- the variety of
    an abstract sheaf

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

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

AbstractSheaf * AbstractSheaf -- (tensor) product of two abstract sheaves
*************************************************************************

Synopsis
========

  * Operator: * (Macaulay2Doc),
  * Usage:
        F*G
        F**G
  * Inputs:
      * F,
      * G,
  * Outputs:
      * the (tensor) product of $F$ and $G$

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

If F or G is a ring element of degree 0, it represents a trivial bundle of that
rank.

+-----------------------------------------------+
|i1 : X = abstractProjectiveSpace 1             |
|                                               |
|o1 = X                                         |
|                                               |
|o1 : a flag bundle with subquotient ranks {2:1}|
+-----------------------------------------------+
|i2 : OO_X(1) * OO_X(2)                         |
|                                               |
|o2 = a sheaf                                   |
|                                               |
|o2 : an abstract sheaf of rank 1 on X          |
+-----------------------------------------------+
|i3 : chi oo                                    |
|                                               |
|o3 = 4                                         |
+-----------------------------------------------+

The sheaves can be on different varieties if one of the varieties is over the
other.

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

  * AbstractSheaf * AbstractSheaf, --
    (tensor) product of two abstract sheaves
  * "AbstractSheaf * QQ"
  * "AbstractSheaf * RingElement"
  * "AbstractSheaf * ZZ"
  * "QQ * AbstractSheaf"
  * "RingElement * AbstractSheaf"
  * "ZZ * AbstractSheaf"

AbstractSheaf + AbstractSheaf -- (direct) sum of two abstract sheaves
*********************************************************************

Synopsis
========

  * Operator: + (Macaulay2Doc),
  * Usage:
        F+G
        F++G
  * Inputs:
      * F,
      * G,
  * Outputs:
      * the (direct) sum of $F$ and $G$.  If one of the arguments is an
        integer, it represents the trivial sheaf of that rank.

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

+-----------------------------------------------+
|i1 : X = abstractProjectiveSpace 1             |
|                                               |
|o1 = X                                         |
|                                               |
|o1 : a flag bundle with subquotient ranks {2:1}|
+-----------------------------------------------+
|i2 : OO_X(1) + OO_X(2)                         |
|                                               |
|o2 = a sheaf                                   |
|                                               |
|o2 : an abstract sheaf of rank 2 on X          |
+-----------------------------------------------+
|i3 : chi oo                                    |
|                                               |
|o3 = 5                                         |
+-----------------------------------------------+
|i4 : 1 + OO_X(1)                               |
|                                               |
|o4 = a sheaf                                   |
|                                               |
|o4 : an abstract sheaf of rank 2 on X          |
+-----------------------------------------------+
|i5 : chi oo                                    |
|                                               |
|o5 = 3                                         |
+-----------------------------------------------+

The sheaves can be on different varieties if one of the varieties is over the
other.

+----------------------------------------------------------+
|i6 : ch OO_X(1)                                           |
|                                                          |
|o6 = 1 + H                                                |
|          2,1                                             |
|                                                          |
|         QQ[][h, H   ]                                    |
|                  2,1                                     |
|o6 : ---------------------                                |
|     (- h - H   , -h*H   )                                |
|             2,1      2,1                                 |
+----------------------------------------------------------+
|i7 : Y = abstractProjectiveSpace'(3,X,VariableName=>k)    |
|                                                          |
|o7 = Y                                                    |
|                                                          |
|o7 : a flag bundle with subquotient ranks {3, 1}          |
+----------------------------------------------------------+
|i8 : ch OO_Y(2)                                           |
|                                                          |
|                2   4 3                                   |
|o8 = 1 + 2k + 2k  + -k                                    |
|                    3                                     |
|                                                          |
|                 QQ[][h, H   ]                            |
|                          2,1                             |
|             ---------------------[H   ..H   , k]         |
|             (- h - H   , -h*H   )  1,1   1,3             |
|                     2,1      2,1                         |
|o8 : ---------------------------------------------------- |
|     (- H    - k, - H    - H   k, - H    - H   k, -H   k) |
|         1,1         1,2    1,1      1,3    1,2     1,3   |
+----------------------------------------------------------+
|i9 : OO_Y(2) ++ OO_X(1)                                   |
|                                                          |
|o9 = a sheaf                                              |
|                                                          |
|o9 : an abstract sheaf of rank 2 on Y                     |
+----------------------------------------------------------+
|i10 : ch oo                                               |
|                                                          |
|                          2   4 3                         |
|o10 = 2 + (2k + H   ) + 2k  + -k                          |
|                 2,1          3                           |
|                                                          |
|                  QQ[][h, H   ]                           |
|                           2,1                            |
|              ---------------------[H   ..H   , k]        |
|              (- h - H   , -h*H   )  1,1   1,3            |
|                      2,1      2,1                        |
|o10 : ----------------------------------------------------|
|      (- H    - k, - H    - H   k, - H    - H   k, -H   k)|
|          1,1         1,2    1,1      1,3    1,2     1,3  |
+----------------------------------------------------------+
|i11 : chi ooo                                             |
|                                                          |
|o11 = 12                                                  |
+----------------------------------------------------------+

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

  * AbstractSheaf + AbstractSheaf, --
    (direct) sum of two abstract sheaves
  * "AbstractSheaf + QQ"
  * "AbstractSheaf + RingElement"
  * "AbstractSheaf + ZZ"
  * "QQ + AbstractSheaf"
  * "RingElement + AbstractSheaf"
  * "ZZ + AbstractSheaf"

AbstractSheaf - AbstractSheaf -- difference of two abstract sheaves
*******************************************************************

Synopsis
========

  * Operator: - (Macaulay2Doc),
  * Usage:
        F-G
  * Inputs:
      * F,
      * G,
  * Outputs:
      * the difference of $F$ and $G$.  If one of the arguments is an integer,
        it represents the trivial sheaf of that rank.

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

+-----------------------------------------------+
|i1 : X = abstractProjectiveSpace 1             |
|                                               |
|o1 = X                                         |
|                                               |
|o1 : a flag bundle with subquotient ranks {2:1}|
+-----------------------------------------------+
|i2 : OO_X(1) - OO_X(2)                         |
|                                               |
|o2 = a sheaf                                   |
|                                               |
|o2 : an abstract sheaf of rank 0 on X          |
+-----------------------------------------------+
|i3 : chi oo                                    |
|                                               |
|o3 = -1                                        |
+-----------------------------------------------+

The sheaves can be on different varieties if one of the varieties is over the
other.

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

  * AbstractSheaf - AbstractSheaf, --
    difference of two abstract sheaves
  * "AbstractSheaf - QQ"
  * "AbstractSheaf - RingElement"
  * "AbstractSheaf - ZZ"
  * "QQ - AbstractSheaf"
  * "RingElement - AbstractSheaf"
  * "ZZ - AbstractSheaf"

AbstractSheaf ^ ZZ -- power of an abstract sheaf
************************************************

Synopsis
========

  * Operator: ^ (Macaulay2Doc),
  * Usage:
        F^n
  * Inputs:
      * F,
      * n,
  * Outputs:
      * the n-th Cartesian power of F, which amounts to multiplication by n in
        the Grothendieck group

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

Maybe we should remove this operation, in favor of ZZ * AbstractSheaf.

+-----------------------------------------------+
|i1 : X = abstractProjectiveSpace 1             |
|                                               |
|o1 = X                                         |
|                                               |
|o1 : a flag bundle with subquotient ranks {2:1}|
+-----------------------------------------------+
|i2 : F = OO_X(1)                               |
|                                               |
|o2 = F                                         |
|                                               |
|o2 : an abstract sheaf of rank 1 on X          |
+-----------------------------------------------+
|i3 : chi F^10                                  |
|                                               |
|o3 = 20                                        |
+-----------------------------------------------+

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

  * AbstractSheaf ^ ZZ -- power of an abstract sheaf

AbstractSheaf ^** RingElement -- tensor power of an abstract sheaf
******************************************************************

Synopsis
========

  * Operator: ^** (Macaulay2Doc),
  * Usage:
        F^**n
  * Inputs:
      * F, of rank 1 if n is not an integer
      * n, in (or promotable to) the intersection ring of the variety of $F$
  * Outputs:
      * the $n$-th tensor power of $F$

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

+------------------------------------------------+
|i1 : pt = base n                                |
|                                                |
|o1 = pt                                         |
|                                                |
|o1 : an abstract variety of dimension 0         |
+------------------------------------------------+
|i2 : X = abstractProjectiveSpace'(3,pt)         |
|                                                |
|o2 = X                                          |
|                                                |
|o2 : a flag bundle with subquotient ranks {3, 1}|
+------------------------------------------------+
|i3 : A = intersectionRing X                     |
|                                                |
|o3 = A                                          |
|                                                |
|o3 : QuotientRing                               |
+------------------------------------------------+
|i4 : ch ((OO_X(1)) ^** 2)                       |
|                                                |
|                2   4 3                         |
|o4 = 1 + 2h + 2h  + -h                          |
|                    3                           |
|                                                |
|o4 : A                                          |
+------------------------------------------------+
|i5 : ch ((OO_X(1)) ^** 3)                       |
|                                                |
|              9 2   9 3                         |
|o5 = 1 + 3h + -h  + -h                          |
|              2     2                           |
|                                                |
|o5 : A                                          |
+------------------------------------------------+
|i6 : ch ((OO_X(1)) ^** n)                       |
|                                                |
|               1 2 2   1 3 3                    |
|o6 = 1 + n*h + -n h  + -n h                     |
|               2       6                        |
|                                                |
|o6 : A                                          |
+------------------------------------------------+

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

  * "AbstractSheaf ^** QQ"
  * AbstractSheaf ^** RingElement, --
    tensor power of an abstract sheaf
  * "AbstractSheaf ^** ZZ"

abstractSheaf(AbstractVariety,RingElement) -- make an abstract sheaf
********************************************************************

Synopsis
========

  * Function: abstractSheaf,
  * Usage:
        abstractSheaf(X,cc,Rank=>n)
        abstractSheaf(X,Rank=>n)
        abstractSheaf(X,ChernClass=>c,Rank=>n)
        abstractSheaf(X,ChernCharacter=>cc)
  * Inputs:
      * X,
      * cc, an element of the intersection ring of X
  * Optional inputs (Macaulay2Doc),:
      * Rank => a ring element (Macaulay2Doc), default value
        null
      * ChernCharacter => a ring element (Macaulay2Doc),
        default value null
      * ChernClass => a ring element (Macaulay2Doc), default
        value null
      * Name => a thing (Macaulay2Doc), default value null
  * Outputs:
      * an abstract sheaf, the abstract sheaf over X with
        total Chern class c, rank n, and total Chern character cc.  When just
        the rank is specified, the Chern class is taken to be 1.  If the Rank
        and ChernCharacter options are both given, the value of the Rank option
        is ignored.  If the ChernClass and ChernCharacter options are both
        given, the values are used without checking for compatibility.
  * Consequences:
      * The value of the Name option should be a symbol or indexed variable to
        which the sheaf will be assigned. The function baseName (Macaulay2Doc),
        will return it, so the sheaf can be used in
        situations where a symbol is expected. The sheaves created by
        base, use this facility.

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

+--------------------------------------------------+
|i1 : X = abstractVariety(3, QQ[c])                |
|                                                  |
|o1 = X                                            |
|                                                  |
|o1 : an abstract variety of dimension 3           |
+--------------------------------------------------+
|i2 : F = abstractSheaf(X, ChernCharacter => 3 + c)|
|                                                  |
|o2 = F                                            |
|                                                  |
|o2 : an abstract sheaf of rank 3 on X             |
+--------------------------------------------------+
|i3 : ch F                                         |
|                                                  |
|o3 = 3 + c                                        |
|                                                  |
|o3 : QQ[c]                                        |
+--------------------------------------------------+
|i4 : chern F                                      |
|                                                  |
|             1 2   1 3                            |
|o4 = 1 + c + -c  + -c                             |
|             2     6                              |
|                                                  |
|o4 : QQ[c]                                        |
+--------------------------------------------------+

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

  * "abstractSheaf(AbstractVariety)"
  * "abstractSheaf(AbstractVariety,QQ)"
  * abstractSheaf(AbstractVariety,RingElement)
    -- make an abstract sheaf
  * "abstractSheaf(AbstractVariety,ZZ)"

AbstractVariety -- the class of all abstract varieties
******************************************************

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

An abstract variety in Schubert2 is defined by its dimension and by a
$\QQ$-algebra $A$, interpreted as the intersection ring. For example, the
following code defines the abstract variety corresponding to $\PP^2$.

+---------------------------------------+
|i1 : A=QQ[t]/ideal(t^3)                |
|                                       |
|o1 = A                                 |
|                                       |
|o1 : QuotientRing                      |
+---------------------------------------+
|i2 : X=abstractVariety(2,A)            |
|                                       |
|o2 = X                                 |
|                                       |
|o2 : an abstract variety of dimension 2|
+---------------------------------------+

Once the variety $X$ is created, we can access its structure sheaf $O_X$ via
the operator OO, and view its Chern class:

+-------------------------------------+
|i3 : OO_X                            |
|                                     |
|o3 = a sheaf                         |
|                                     |
|o3 : an abstract sheaf of rank 1 on X|
+-------------------------------------+
|i4 : chern OO_X                      |
|                                     |
|o4 = 1                               |
|                                     |
|o4 : A                               |
+-------------------------------------+

A variable of type AbstractVariety, is implemented as a
mutable hash table (Macaulay2Doc), and can contain
other information, such as the variety's tangent bundle, stored under the key
TangentBundle. Installation of a variety's tangent bundle
enables the computation of its Todd class.

+---------------------------------------------------------------------+
|i5 : X.TangentBundle  = abstractSheaf(X,Rank=>2, ChernClass=>(1+t)^3)|
|                                                                     |
|o5 = a sheaf                                                         |
|                                                                     |
|o5 : an abstract sheaf of rank 2 on X                                |
+---------------------------------------------------------------------+
|i6 : todd X                                                          |
|                                                                     |
|         3     2                                                     |
|o6 = 1 + -t + t                                                      |
|         2                                                           |
|                                                                     |
|o6 : A                                                               |
+---------------------------------------------------------------------+

To enable the computation of such things as the Euler characteristic of a
sheaf, we must also specify a method to take the integral, of
an element of the intersection ring $A$; in the case where $A$ is Gorenstein,
as is the case for the intersection ring modulo numerical equivalence of a
complete nonsingular variety, the integral can often be implemented as the
functional that takes the coefficient of the highest degree component with
respect to a suitable basis of monomials.  The default integration method
installed by such functions as base, and abstractVariety,
for varieties of dimension greater than 0
returns a symbolic expression indicating the further integration that ought to
be done. In this example, we choose to implement the integral by taking the
coefficient of the monomial in our ring of top degree.

+-------------------------------------------+
|i7 : integral A := f -> coefficient(t^2,f);|
+-------------------------------------------+

Now we can compute the Euler characteristic of the line bundle whose first
Chern class is $2t$ (the algorithm uses the Todd class and the Riemann-Roch
formula):

+------------------+
|i8 : chi OO_X(2*t)|
|                  |
|o8 = 6            |
|                  |
|o8 : QQ           |
+------------------+

There are several other methods for constructing abstract varieties: the
following functions construct basic useful varieties:
abstractProjectiveSpace, projectiveBundle,
see flagBundle, and base.

See also
========

  * abstractVariety -- make an abstract
    variety
  * AbstractSheaf -- the class of all abstract sheaves
  * chern -- compute Chern classes of a sheaf
  * chi (Macaulay2Doc)
  * TangentBundle -- a symbol used internally as a key
  * todd -- compute the Todd class of an abstract sheaf, variety,
    map

Types of abstract variety:
==========================

  * FlagBundle -- the class of all flag bundles

Functions and methods returning an abstract variety:
====================================================

  * "abstractVariety" -- see abstractVariety(ZZ,Ring),
    -- make an abstract variety
  * base -- make an abstract variety from nothing, equipped with
    some parameters and some bundles
  * "degeneracyLocus" -- see
    degeneracyLocus(ZZ,AbstractSheaf,AbstractSheaf),
  * "intermediates(IncidenceCorrespondence)" -- see intermediates,
  * "kernelBundle" -- see kernelBundle(ZZ,AbstractSheaf,AbstractSheaf),
  * "sectionZeroLocus" -- see sectionZeroLocus(AbstractSheaf),
  * source(AbstractVarietyMap) -- the
    source of a map of abstract varieties
  * source(Correspondence) -- the source of
    a correspondence
  * target(AbstractVarietyMap) -- the
    target of a map of abstract varieties
  * target(Correspondence) -- the target of
    a correspondence
  * use(AbstractVariety) -- assign values to
    variables associated with a variety
  * variety(AbstractSheaf) -- the variety of
    an abstract sheaf

Methods that use an abstract variety:
=====================================

  * "abstractProjectiveSpace(ZZ,AbstractVariety)" -- see
    abstractProjectiveSpace, -- make a projective
    space
  * "abstractProjectiveSpace'(ZZ,AbstractVariety)" -- see
    abstractProjectiveSpace', -- make a projective
    space
  * "abstractSheaf(AbstractVariety)" -- see
    abstractSheaf(AbstractVariety,RingElement),
    -- make an abstract sheaf
  * "abstractSheaf(AbstractVariety,QQ)" -- see
    abstractSheaf(AbstractVariety,RingElement),
    -- make an abstract sheaf
  * abstractSheaf(AbstractVariety,RingElement)
    -- make an abstract sheaf
  * "abstractSheaf(AbstractVariety,ZZ)" -- see
    abstractSheaf(AbstractVariety,RingElement),
    -- make an abstract sheaf
  * AbstractVariety / AbstractVariety,
    -- get a structure map
  * "abstractVarietyMap(AbstractVariety,AbstractVariety,MethodFunction,
    MethodFunction)" -- see abstractVarietyMap, --
    make an abstract variety morphism
  * "abstractVarietyMap(AbstractVariety,AbstractVariety,RingMap,MethodFunction
    )" -- see abstractVarietyMap, -- make an abstract
    variety morphism
  * "cotangentBundle(AbstractVariety)" -- see cotangentBundle,
    -- get the cotangent bundle
  * dim(AbstractVariety) -- the dimension of
    an abstract variety
  * euler(AbstractVariety)
  * "exceptionalDivisor(AbstractVariety)" -- see exceptionalDivisor,
    -- get the exceptional divisor of a blowup
  * "flagBundle(List,AbstractVariety)" -- see flagBundle, --
    make a flag bundle
  * intersectionRing(AbstractVariety)
    -- get the intersection ring of an
    abstract variety
  * map(FlagBundle,AbstractVariety,AbstractSheaf)
    -- maps to
    projective bundles
  * "map(FlagBundle,AbstractVariety,List)" -- see
    map(FlagBundle,AbstractVarietyMap,List),
    -- make a map from an
    abstract variety to a flag bundle
  * OO _ AbstractVariety -- the structure sheaf
    of an abstract variety
  * "projectiveBundle(ZZ,AbstractVariety)" -- see projectiveBundle,
    -- make a projective bundle from an abstract sheaf
  * "projectiveBundle'(ZZ,AbstractVariety)" -- see projectiveBundle',
    -- make a projective bundle from an abstract sheaf
  * "tangentBundle(AbstractVariety)" -- see tangentBundle,
    -- get the tangent bundle
  * "tautologicalLineBundle(AbstractVariety)" -- see
    tautologicalLineBundle, -- get the tautological
    line bundle of a flag bundle or abstract variety
  * "todd(AbstractVariety)" -- see todd, -- compute the Todd class
    of an abstract sheaf, variety, map

Protected objects of class AbstractVariety:
===========================================

  * point -- the default base variety of dimension 0

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

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

AbstractVariety / AbstractVariety -- get a structure map
********************************************************

Synopsis
========

  * Operator: / (Macaulay2Doc),
  * Usage:
        X/S
  * Inputs:
      * X,
      * S,
  * Outputs:
      * the structure map or composition of structure maps $X \rightarrow{} S$

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

+------------------------------------------------+
|i1 : X = abstractProjectiveSpace_3 point        |
|                                                |
|o1 = X                                          |
|                                                |
|o1 : a flag bundle with subquotient ranks {1, 3}|
+------------------------------------------------+
|i2 : Y = abstractProjectiveSpace_2 X            |
|                                                |
|o2 = Y                                          |
|                                                |
|o2 : a flag bundle with subquotient ranks {1..2}|
+------------------------------------------------+
|i3 : Z = abstractProjectiveSpace_1 Y            |
|                                                |
|o3 = Z                                          |
|                                                |
|o3 : a flag bundle with subquotient ranks {2:1} |
+------------------------------------------------+
|i4 : Z/Z                                        |
|                                                |
|o4 = a variety map                              |
|                                                |
|o4 : a map to Z from Z                          |
+------------------------------------------------+
|i5 : Z/Y                                        |
|                                                |
|o5 = a variety map                              |
|                                                |
|o5 : a map to Y from Z                          |
+------------------------------------------------+
|i6 : Z/X                                        |
|                                                |
|o6 = a variety map                              |
|                                                |
|o6 : a map to X from Z                          |
+------------------------------------------------+
|i7 : Z/point                                    |
|                                                |
|o7 = a variety map                              |
|                                                |
|o7 : a map to point from Z                      |
+------------------------------------------------+

See also
========

  * StructureMap -- get the structure map of an abstract
    variety

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

  * AbstractVariety / AbstractVariety,
    -- get a structure map

abstractVariety(ZZ,Ring) -- make an abstract variety
****************************************************

Synopsis
========

  * Function: abstractVariety,
  * Usage:
        abstractVariety(d,A)
  * Inputs:
      * d,
      * A, of degree length 1
  * Optional inputs (Macaulay2Doc),:
      * ReturnType => a type (Macaulay2Doc), default value
        AbstractVariety, a type of AbstractVariety
      * DefaultIntegral => a Boolean value (Macaulay2Doc),
        default value true
  * Outputs:
      * of dimension d whose intersection ring is A and whose class (Macaulay2Doc),
        is the value of the ReturnType option
  * Consequences:
      * The ring A is altered so it knows what abstract variety it is
        associated with (see variety(Ring) (Varieties)),
        preventing it from being used in this
        way more than once.  The methods for converting its elements to strings
        and nets are replaced by methods that display monomials of higher
        degree further to the right, parenthesizing multiple terms of the same
        degree.
      * Unless DefaultIntegral, is set to
        false, a default method for integration of elements of the intersection
        ring is installed, which returns a formal expression (Macaulay2Doc),
        representing the integral of the degree $d$
        part of the element when $d$ is greater than zero, and simply returns
        the degree 0 part of the element when $d$ is zero.

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

+---------------------------------------------------+
|i1 : X = abstractVariety(3, QQ[c,d,Degrees=>{1,2}])|
|                                                   |
|o1 = X                                             |
|                                                   |
|o1 : an abstract variety of dimension 3            |
+---------------------------------------------------+
|i2 : F = abstractSheaf(X, ChernCharacter => 3+c+d) |
|                                                   |
|o2 = F                                             |
|                                                   |
|o2 : an abstract sheaf of rank 3 on X              |
+---------------------------------------------------+
|i3 : chern F                                       |
|                                                   |
|              1 2         1 3                      |
|o3 = 1 + c + (-c  - d) + (-c  - c*d)               |
|              2           6                        |
|                                                   |
|o3 : QQ[c..d]                                      |
+---------------------------------------------------+
|i4 : integral oo                                   |
|                                                   |
|              1 3                                  |
|o4 = integral(-c  - c*d)                           |
|              6                                    |
|                                                   |
|o4 : Expression of class Adjacent                  |
+---------------------------------------------------+

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

  * abstractVariety(ZZ,Ring) -- make an
    abstract variety

AbstractVarietyMap -- the class of all abstract variety maps
************************************************************

Functions and methods returning an abstract variety map:
========================================================

  * AbstractVariety / AbstractVariety,
    -- get a structure map
  * abstractVarietyMap -- make an abstract variety
    morphism
  * AbstractVarietyMap * AbstractVarietyMap
    -- composition of maps of abstract varieties
  * "map(FlagBundle,AbstractVariety,List)" -- see
    map(FlagBundle,AbstractVarietyMap,List),
    -- make a map from an
    abstract variety to a flag bundle
  * map(FlagBundle,AbstractVarietyMap,List)
    -- make a map from an
    abstract variety to a flag bundle

Methods that use an abstract variety map:
=========================================

  * AbstractVarietyMap ^* -- pull back operator
    associated to a map of varieties
  * AbstractVarietyMap _* -- push forward
    operator associated to a map of varieties
  * "blowup(AbstractVarietyMap)" -- see blowup, -- blow up an
    abstract variety along a subvariety
  * "cotangentBundle(AbstractVarietyMap)" -- see cotangentBundle,
    -- get the cotangent bundle
  * dim(AbstractVarietyMap) -- the
    dimension of an abstract variety
  * sectionClass(AbstractVarietyMap)
    -- get the class of the image of a
    section of a map of abstract varieties
  * source(AbstractVarietyMap) -- the
    source of a map of abstract varieties
  * "tangentBundle(AbstractVarietyMap)" -- see tangentBundle,
    -- get the tangent bundle
  * target(AbstractVarietyMap) -- the
    target of a map of abstract varieties
  * "todd(AbstractVarietyMap)" -- see todd, -- compute the Todd
    class of an abstract sheaf, variety, map

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

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

abstractVarietyMap -- make an abstract variety morphism
*******************************************************

Synopsis
========

  * Usage:
        f = abstractVarietyMap(Y,X,fUpper,fLower)
  * Inputs:
      * Y, an abstract variety, the target of $f$
      * X, an abstract variety, the source of $f$
      * fUpper, the method for pulling back from $Y$ to $X$; if given as a ring
        map, this should be a ring map from the intersection ring of $Y$ to
        that of $X$.  If given as a MethodFunction, there must be a method
        installed for pulling back elements of the intersection ring of $Y$ to
        that of $X$.  Optionally, a method can also be given for pulling back
        sheaves from $Y$ to $X$, in which case the DefaultPullBack => false
        option must be set to override the default behavior.
      * fLower, the method from pushing forward from $X$ to $Y$. Must have a
        method installed for pushing forward elements of the intersection ring
        of $X$ to that of $Y$.  Optionally, a method can also be given for
        pushing forward sheaves from $X$ to $Y$, in which case the
        DefaultPushForward => false option must be set to override the default
        behavior.
  * Optional inputs (Macaulay2Doc),:
      * DefaultPullBack => a Boolean value (Macaulay2Doc),
        default value true, if true, sheaf pullbacks are computed in the
        default manner from ring element pullbacks
      * DefaultPushForward => a Boolean value (Macaulay2Doc),
        default value true, if true, sheaf pushforwards are computed (if
        possible) in the default manner from ring element pushforwards
      * TangentBundle => an abstract sheaf, default value
        null, the relative tangent bundle of $f$.  If not supplied, is computed
        anyway if possible.
      * SectionClass => a ring element (Macaulay2Doc),
        default value null, the class of a section of $f$, an element of the
        intersection ring of $X$
  * Outputs:
      * f, an abstract variety map, the resulting
        map from $X$ to $Y$
  * Consequences:
      * If fUpper is given as a ring map, then a new method is created for the
        pullback, encapsulating this ring map.  However, if fUpper is given as
        a MethodFunction, then this MethodFunction is used directly, and may
        have new methods installed on it.
      * If the DefaultPullBack => true option is set (this is the default
        setting), then a method for pulling back sheaves is installed in the
        method fUpper.  The default behavior is to pull back both Chern classes
        and Chern characters via the supplied map.
      * If the DefaultPullBack => true option is set (this is the default
        setting), and if the calculation of sheaf pushforward is possible (i.e.
        either $X$ and $Y$ have supplied tangent bundles and $fUpper$ can pull
        back sheaves, or the TangentBundle option is set), method for pulling
        back sheaves is installed in the method fUpper.  The default behavior
        is to compute the pushforward of sheaves via Grothendieck-Riemann-Roch.

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

Typically it is inconvenient to have to use this function unless absolutely
necessary.  Consider whether the morphism you need may be built via one of the
built-in maps, for example via
map(FlagBundle,AbstractVariety,AbstractSheaf).

+-----------------------------------------------------------+
|i1 : X = point                                             |
|                                                           |
|o1 = point                                                 |
|                                                           |
|o1 : an abstract variety of dimension 0                    |
+-----------------------------------------------------------+
|i2 : RX = intersectionRing X                               |
|                                                           |
|o2 = RX                                                    |
|                                                           |
|o2 : PolynomialRing                                        |
+-----------------------------------------------------------+
|i3 : Y = abstractProjectiveSpace 3                         |
|                                                           |
|o3 = Y                                                     |
|                                                           |
|o3 : a flag bundle with subquotient ranks {1, 3}           |
+-----------------------------------------------------------+
|i4 : RY = intersectionRing Y                               |
|                                                           |
|o4 = RY                                                    |
|                                                           |
|o4 : QuotientRing                                          |
+-----------------------------------------------------------+
|i5 : fUpper = map(RX, RY, splice{4:0_RX})                  |
|                                                           |
|o5 = map (RX, RY, {0, 0, 0, 0})                            |
|                                                           |
|o5 : RingMap RX <-- RY                                     |
+-----------------------------------------------------------+
|i6 : fLower = method()                                     |
|                                                           |
|o6 = fLower                                                |
|                                                           |
|o6 : MethodFunction                                        |
+-----------------------------------------------------------+
|i7 : fLower RX := a -> promote(a,RY) * ctop last bundles Y;|
+-----------------------------------------------------------+
|i8 : incl = abstractVarietyMap(Y,X,fUpper,fLower)          |
|                                                           |
|o8 = incl                                                  |
|                                                           |
|o8 : a map to Y from point                                 |
+-----------------------------------------------------------+
|i9 : integral incl_* 1_RX                                  |
|                                                           |
|o9 = 1                                                     |
+-----------------------------------------------------------+

This same example can be done much more easily via:

+-------------------------------------------------+
|i10 : X = point                                  |
|                                                 |
|o10 = point                                      |
|                                                 |
|o10 : an abstract variety of dimension 0         |
+-------------------------------------------------+
|i11 : Y = abstractProjectiveSpace 3              |
|                                                 |
|o11 = Y                                          |
|                                                 |
|o11 : a flag bundle with subquotient ranks {1, 3}|
+-------------------------------------------------+
|i12 : incl = map(Y,X,OO_X)                       |
|                                                 |
|o12 = incl                                       |
|                                                 |
|o12 : a map to Y from point                      |
+-------------------------------------------------+

Ways to use abstractVarietyMap:
===============================

  * "abstractVarietyMap(AbstractVariety,AbstractVariety,MethodFunction,
    MethodFunction)"
  * "abstractVarietyMap(AbstractVariety,AbstractVariety,RingMap,MethodFunction
    )"

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

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

AbstractVarietyMap * AbstractVarietyMap -- composition of maps of abstract varieties
************************************************************************************

Synopsis
========

  * Operator: * (Macaulay2Doc),
  * Usage:
        g*f
  * Inputs:
      * g,
      * f,
  * Outputs:
      * the composition of g and f

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

+------------------------------------------------+
|i1 : X = abstractProjectiveSpace_3 point        |
|                                                |
|o1 = X                                          |
|                                                |
|o1 : a flag bundle with subquotient ranks {1, 3}|
+------------------------------------------------+
|i2 : Y = abstractProjectiveSpace_4 X            |
|                                                |
|o2 = Y                                          |
|                                                |
|o2 : a flag bundle with subquotient ranks {1, 4}|
+------------------------------------------------+
|i3 : Y.StructureMap                             |
|                                                |
|o3 = a variety map                              |
|                                                |
|o3 : a map to X from Y                          |
+------------------------------------------------+
|i4 : X.StructureMap * Y.StructureMap            |
|                                                |
|o4 = a variety map                              |
|                                                |
|o4 : a map to point from Y                      |
+------------------------------------------------+

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

  * AbstractVarietyMap * AbstractVarietyMap
    -- composition of maps of abstract varieties

AbstractVarietyMap ^* -- pull back operator associated to a map of varieties
****************************************************************************

Synopsis
========

  * Operator: ^* (Macaulay2Doc),
  * Usage:
        f^*
  * Inputs:
      * f,
  * Outputs:
      * the pull back operator associated to f, a function that can be applied
        to an abstract sheaf or a cycle class

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

+-----------------------------------------------------------------------------+
|i1 : S = base(4, Bundle => (E,4,c) )                                         |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : an abstract variety of dimension 4                                      |
+-----------------------------------------------------------------------------+
|i2 : X = flagBundle( {2,2}, E )                                              |
|                                                                             |
|o2 = X                                                                       |
|                                                                             |
|o2 : a flag bundle with subquotient ranks {2:2}                              |
+-----------------------------------------------------------------------------+
|i3 : f = X.StructureMap                                                      |
|                                                                             |
|o3 = f                                                                       |
|                                                                             |
|o3 : a map to S from X                                                       |
+-----------------------------------------------------------------------------+
|i4 : chern E                                                                 |
|                                                                             |
|o4 = 1 + c  + c  + c  + c                                                    |
|          1    2    3    4                                                   |
|                                                                             |
|o4 : QQ[c ..c ]                                                              |
|         1   4                                                               |
+-----------------------------------------------------------------------------+
|i5 : f^* oo                                                                  |
|                                                                             |
|o5 = 1 + c  + c  + c  + c                                                    |
|          1    2    3    4                                                   |
|                                                                             |
|                                          QQ[c ..c ][H   ..H   ]             |
|                                              1   4   1,1   2,2              |
|o5 : ------------------------------------------------------------------------|
|     (- H    - H    + c , - H    - H   H    - H    + c , - H   H    - H   H  |
|         1,1    2,1    1     1,2    1,1 2,1    2,2    2     1,2 2,1    1,1 2,|
|-----------------------------------------------------------------------------|
|------------------------                                                     |
|  + c , - H   H    + c )                                                     |
|2    3     1,2 2,2    4                                                      |
+-----------------------------------------------------------------------------+
|i6 : f^* E                                                                   |
|                                                                             |
|o6 = a sheaf                                                                 |
|                                                                             |
|o6 : an abstract sheaf of rank 4 on X                                        |
+-----------------------------------------------------------------------------+
|i7 : chern oo                                                                |
|                                                                             |
|o7 = 1 + c  + c  + c  + c                                                    |
|          1    2    3    4                                                   |
|                                                                             |
|                                          QQ[c ..c ][H   ..H   ]             |
|                                              1   4   1,1   2,2              |
|o7 : ------------------------------------------------------------------------|
|     (- H    - H    + c , - H    - H   H    - H    + c , - H   H    - H   H  |
|         1,1    2,1    1     1,2    1,1 2,1    2,2    2     1,2 2,1    1,1 2,|
|-----------------------------------------------------------------------------|
|------------------------                                                     |
|  + c , - H   H    + c )                                                     |
|2    3     1,2 2,2    4                                                      |
+-----------------------------------------------------------------------------+

See also
========

  * AbstractVarietyMap _* -- push forward
    operator associated to a map of varieties

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

  * AbstractVarietyMap ^* -- pull back operator
    associated to a map of varieties

AbstractVarietyMap _* -- push forward operator associated to a map of varieties
*******************************************************************************

Synopsis
========

  * Operator: _* (Macaulay2Doc),
  * Usage:
        f_*
  * Inputs:
      * f,
  * Outputs:
      * the push forward operator associated to f, a function that can be
        applied to an abstract sheaf or a cycle class

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

+-------------------------------------------------------------------------+
|i1 : X = abstractProjectiveSpace' 4                                      |
|                                                                         |
|o1 = X                                                                   |
|                                                                         |
|o1 : a flag bundle with subquotient ranks {4, 1}                         |
+-------------------------------------------------------------------------+
|i2 : f = X.StructureMap                                                  |
|                                                                         |
|o2 = f                                                                   |
|                                                                         |
|o2 : a map to point from X                                               |
+-------------------------------------------------------------------------+
|i3 : OO_X(1)                                                             |
|                                                                         |
|o3 = a sheaf                                                             |
|                                                                         |
|o3 : an abstract sheaf of rank 1 on X                                    |
+-------------------------------------------------------------------------+
|i4 : f_* oo                                                              |
|                                                                         |
|o4 = a sheaf                                                             |
|                                                                         |
|o4 : an abstract sheaf of rank 5 on point                                |
+-------------------------------------------------------------------------+
|i5 : ch OO_X(1)                                                          |
|                                                                         |
|             1 2   1 3    1 4                                            |
|o5 = 1 + h + -h  + -h  + --h                                             |
|             2     6     24                                              |
|                                                                         |
|                              QQ[][H   ..H   , h]                        |
|                                    1,1   1,4                            |
|o5 : --------------------------------------------------------------------|
|     (- H    - h, - H    - H   h, - H    - H   h, - H    - H   h, -H   h)|
|         1,1         1,2    1,1      1,3    1,2      1,4    1,3     1,4  |
+-------------------------------------------------------------------------+
|i6 : f_* oo                                                              |
|                                                                         |
|      1                                                                  |
|o6 = --                                                                  |
|     24                                                                  |
|                                                                         |
|o6 : QQ[]                                                                |
+-------------------------------------------------------------------------+

See also
========

  * integral -- compute an integral (push forward a cycle to
    the base)
  * AbstractVarietyMap ^* -- pull back operator
    associated to a map of varieties

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

  * AbstractVarietyMap _* -- push forward
    operator associated to a map of varieties

adams -- compute Adams operations
*********************************

Ways to use adams:
==================

  * adams(ZZ,AbstractSheaf) -- compute
    Adams operations
  * adams(ZZ,RingElement) -- compute Adams
    operations

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

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

adams(ZZ,AbstractSheaf) -- compute Adams operations
***************************************************

Synopsis
========

  * Function: adams,
  * Usage:
        adams(i,F)
        adams_i F
  * Inputs:
      * i,
      * F,
  * Outputs:
      * the effect of $i$-th Adams operation on $F$

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

+----------------------------------------------------------+
|i1 : X = abstractVariety(3, QQ[c,d,e,Degrees=>{1,2,3}])   |
|                                                          |
|o1 = X                                                    |
|                                                          |
|o1 : an abstract variety of dimension 3                   |
+----------------------------------------------------------+
|i2 : F = abstractSheaf(X, ChernCharacter => 1 + c + d + e)|
|                                                          |
|o2 = F                                                    |
|                                                          |
|o2 : an abstract sheaf of rank 1 on X                     |
+----------------------------------------------------------+
|i3 : adams_3 F                                            |
|                                                          |
|o3 = a sheaf                                              |
|                                                          |
|o3 : an abstract sheaf of rank 1 on X                     |
+----------------------------------------------------------+
|i4 : ch oo                                                |
|                                                          |
|o4 = 1 + 3c + 9d + 27e                                    |
|                                                          |
|o4 : QQ[c..e]                                             |
+----------------------------------------------------------+

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

  * adams(ZZ,AbstractSheaf) -- compute
    Adams operations

adams(ZZ,RingElement) -- compute Adams operations
*************************************************

Synopsis
========

  * Function: adams,
  * Usage:
        adams(i,f)
        adams_i f
  * Inputs:
      * i,
      * f,
  * Outputs:
      * the Chern character of the effect of $i$-th Adams operation on the
        abstract sheaf whose Chern character is $f$

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

+-------------------------------------------------------+
|i1 : X = abstractVariety(3, QQ[c,d,e,Degrees=>{1,2,3}])|
|                                                       |
|o1 = X                                                 |
|                                                       |
|o1 : an abstract variety of dimension 3                |
+-------------------------------------------------------+
|i2 : adams(3, 1 + c + d + e)                           |
|                                                       |
|o2 = 1 + 3c + 9d + 27e                                 |
|                                                       |
|o2 : QQ[c..e]                                          |
+-------------------------------------------------------+

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

  * adams(ZZ,RingElement) -- compute Adams
    operations

Base -- get the base variety of a flag bundle
*********************************************

Synopsis
========

  * Usage:
        F.Base
  * Inputs:
      * F, an abstract flag bundle,
  * Outputs:
      * an abstract variety, the base variety of $F$

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

+------------------------------------------------+
|i1 : X = abstractProjectiveSpace 4              |
|                                                |
|o1 = X                                          |
|                                                |
|o1 : a flag bundle with subquotient ranks {1, 4}|
+------------------------------------------------+
|i2 : X.Base                                     |
|                                                |
|o2 = point                                      |
|                                                |
|o2 : an abstract variety of dimension 0         |
+------------------------------------------------+
|i3 : Y = abstractProjectiveSpace_3 X            |
|                                                |
|o3 = Y                                          |
|                                                |
|o3 : a flag bundle with subquotient ranks {1, 3}|
+------------------------------------------------+
|i4 : Y.Base                                     |
|                                                |
|o4 = X                                          |
|                                                |
|o4 : a flag bundle with subquotient ranks {1, 4}|
+------------------------------------------------+

Functions with optional argument named Base:
============================================

  * "inclusion(...,Base=>...)" -- see inclusion, -- build the
    freest possible inclusion map

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

The object Base, is a symbol (Macaulay2Doc).

base -- make an abstract variety from nothing, equipped with some parameters and some bundles
*********************************************************************************************

Synopsis
========

  * Usage:
        X = base()
        X = base(p)
        X = base(d,p)
        X = base(d,p,...,Bundle=>(B,r,b),...)
  * Inputs:
      * d, an integer (Macaulay2Doc), if omitted, the value $0$ is
        used
      * p, a symbol (Macaulay2Doc),
      * B, a symbol (Macaulay2Doc),
      * r, an integer (Macaulay2Doc),
      * b, either a symbol (Macaulay2Doc), a string (Macaulay2Doc),
        a list (Macaulay2Doc), of
        symbols (Macaulay2Doc), indexed variables (Macaulay2Doc),
        or Chern class variables,
  * Outputs:
      * an abstract variety, a variety of dimension $d$
        with an intersection ring containing specified variables and specified
        Chern classes of abstract sheaves
  * Consequences:
      * Variables $p$, ..., of degree 0 are in the intersection ring of the
        variety. They are usable as (integer) variables (auxiliary parameters)
        in intersection ring computations.
      * For each option Bundle=>(B,r,b), an abstract sheaf of rank r is created
        and assigned to the variable B. If b is a symbol, then the Chern
        classes of $B$ are assigned to the indexed variables b_1, ..., b_k,
        where $k = min(r,d)$. If b is a string, "d", say, then the Chern
        classes of $B$ are assigned to the variables whose names are d1, d2,
        d3, ... . If b is a list of length $k$, then the Chern classes are
        assigned to its elements.
      * A default method for integration of elements of the intersection ring
        is installed, which returns a formal expression (Macaulay2Doc),
        representing the integral of the degree $d$
        part of the element when $d$ is greater than zero, and simply returns
        the degree 0 part of the element when $d$ is zero.

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

First we make a base variety and illustrate a computation with its two abstract
sheaves:

+-----------------------------------------------------------+
|i1 : S = base(2,p,q, Bundle =>(A,1,a), Bundle => (B,2,"b"))|
|                                                           |
|o1 = S                                                     |
|                                                           |
|o1 : an abstract variety of dimension 2                    |
+-----------------------------------------------------------+
|i2 : intersectionRing S                                    |
|                                                           |
|o2 = QQ[p..q, a , b1, b2]                                  |
|               1                                           |
|                                                           |
|o2 : PolynomialRing                                        |
+-----------------------------------------------------------+
|i3 : degrees oo                                            |
|                                                           |
|o3 = {{0}, {0}, {1}, {1}, {2}}                             |
|                                                           |
|o3 : List                                                  |
+-----------------------------------------------------------+
|i4 : chern (A*B)                                           |
|                                                           |
|                        2                                  |
|o4 = 1 + (2a  + b1) + (a  + a b1 + b2)                     |
|            1           1    1                             |
|                                                           |
|o4 : QQ[p..q, a , b1, b2]                                  |
|               1                                           |
+-----------------------------------------------------------+
|i5 : integral oo                                           |
|                                                           |
|               2                                           |
|o5 = integral(a  + a b1 + b2)                              |
|               1    1                                      |
|                                                           |
|o5 : Expression of class Adjacent                          |
+-----------------------------------------------------------+

Then we make a projective space over it and use the auxiliary parameters p and
q in a computation that checks the projection formula.

+-----------------------------------------------------------------------------+
|i6 : X = abstractProjectiveSpace'(3,S,VariableName => H)                     |
|warning: clearing value of symbol H to allow access to subscripted variables |
|       : debug with expression   debug 204   or with command line option   --|
|                                                                             |
|o6 = X                                                                       |
|                                                                             |
|o6 : a flag bundle with subquotient ranks {3, 1}                             |
|-----------------------------------------------------------------------------|
|based on it                                                                  |
|debug 204                                                                    |
+-----------------------------------------------------------------------------+
|i7 : intersectionRing X                                                      |
|                                                                             |
|              QQ[p..q, a , b1, b2][H   ..H   , H]                            |
|                        1           1,1   1,3                                |
|o7 = ----------------------------------------------------                    |
|     (- H    - H, - H    - H   H, - H    - H   H, -H   H)                    |
|         1,1         1,2    1,1      1,3    1,2     1,3                      |
|                                                                             |
|o7 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i8 : f = X.StructureMap                                                      |
|                                                                             |
|o8 = f                                                                       |
|                                                                             |
|o8 : a map to S from X                                                       |
+-----------------------------------------------------------------------------+
|i9 : x = chern f_* (f^* OO_S(p*a_1) * OO_X(q*H))                             |
|                                                                             |
|          1   3        2     11                   1 2 6 2   1 2 5 2          |
|o9 = 1 + (-p*q a  + p*q a  + --p*q*a  + p*a ) + (--p q a  + -p q a  +        |
|          6     1        1    6     1      1     72     1   6     1          |
|     ------------------------------------------------------------------------|
|     29 2 4 2   23 2 3 2   157 2 2 2   11 2   2                              |
|     --p q a  + --p q a  + ---p q a  + --p q*a )                             |
|     36     1   12     1    72     1   12     1                              |
|                                                                             |
|o9 : QQ[p..q, a , b1, b2]                                                    |
|               1                                                             |
+-----------------------------------------------------------------------------+
|i10 : y = chern f_* OO_X((f^*(p*a_1))+q*H)                                   |
|                                                                             |
|           1   3        2     11                   1 2 6 2   1 2 5 2         |
|o10 = 1 + (-p*q a  + p*q a  + --p*q*a  + p*a ) + (--p q a  + -p q a  +       |
|           6     1        1    6     1      1     72     1   6     1         |
|      -----------------------------------------------------------------------|
|      29 2 4 2   23 2 3 2   157 2 2 2   11 2   2                             |
|      --p q a  + --p q a  + ---p q a  + --p q*a )                            |
|      36     1   12     1    72     1   12     1                             |
|                                                                             |
|o10 : QQ[p..q, a , b1, b2]                                                   |
|                1                                                            |
+-----------------------------------------------------------------------------+
|i11 : x == y                                                                 |
|                                                                             |
|o11 = true                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * abstractProjectiveSpace' -- make a
    projective space
  * base -- make an abstract variety from nothing, equipped with
    some parameters and some bundles
  * StructureMap -- get the structure map of an abstract
    variety
  * chern -- compute Chern classes of a sheaf

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

  * "base(Sequence)"
  * "base(Thing)"

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

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

blowup -- blow up an abstract variety along a subvariety
********************************************************

Synopsis
========

  * Usage:
        (Ytilde, PN, PNmap, Ymap) = blowup(i)
  * Inputs:
      * i, an abstract variety map, the inclusion
        map of the subvariety $X$ to be blown up into the ambient variety $Y$
  * Outputs:
      * Ytilde, an abstract variety, the blowup of $Y$
        along $X$
      * PN, an abstract flag bundle, the exceptional divisor
        of the blowup, the projectivization of the normal bundle of $i$
      * PNmap, an abstract variety map, the
        inclusion of $PN$ into the blowup
      * Ymap, an abstract variety map, the map from
        the blowup down to $Y$
  * Consequences:
      * The exceptional divisor as a sheaf on the blowup can be obtained via
        exceptionalDivisor Ytilde, see exceptionalDivisor.

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

Blowing up a point in $\mathbb{P}^2$:

+-----------------------------------------------------------------------------+
|i1 : X = abstractProjectiveSpace 0                                           |
|                                                                             |
|o1 = X                                                                       |
|                                                                             |
|o1 : a flag bundle with subquotient ranks {1, 0}                             |
+-----------------------------------------------------------------------------+
|i2 : Y = abstractProjectiveSpace 2                                           |
|                                                                             |
|o2 = Y                                                                       |
|                                                                             |
|o2 : a flag bundle with subquotient ranks {1..2}                             |
+-----------------------------------------------------------------------------+
|i3 : i = map(Y,X,OO_X)                                                       |
|                                                                             |
|o3 = i                                                                       |
|                                                                             |
|o3 : a map to Y from X                                                       |
+-----------------------------------------------------------------------------+
|i4 : (Ytilde, PN, PNmap, Ymap) = blowup(i)                                   |
|                                                                             |
|o4 = (Ytilde, PN, PNmap, Ymap)                                               |
|                                                                             |
|o4 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i5 : Ediv = chern(1, exceptionalDivisor Ytilde) -- the class of the          |
|                                                                             |
|o5 = E                                                                       |
|      0                                                                      |
|                                                                             |
|               QQ[][h, H   ..H   ]                                           |
|                        2,1   2,2                                            |
|     --------------------------------------[E ]                              |
|     (- h - H   , - h*H    - H   , -h*H   )  0                               |
|             2,1       2,1    2,2      2,2                                   |
|o5 : ------------------------------------------                              |
|                           2                                                 |
|                 (H   E , E  + H   )                                         |
|                   2,1 0   0    2,2                                          |
|-----------------------------------------------------------------------------|
|exceptional divisor                                                          |
+-----------------------------------------------------------------------------+
|i6 : integral (Ediv^2)                                                       |
|                                                                             |
|o6 = -1                                                                      |
+-----------------------------------------------------------------------------+

As a more interesting example, we can derive the classical formula for the
degree of the zero-dimensional locus of intersection of three surfaces in
$\mathbb{P}^3$ containing a twisted cubic:

+-----------------------------------------------------------------------------+
|i7 : B = base(r,s,t)                                                         |
|                                                                             |
|o7 = B                                                                       |
|                                                                             |
|o7 : an abstract variety of dimension 0                                      |
+-----------------------------------------------------------------------------+
|i8 : X = abstractProjectiveSpace(1, B)                                       |
|                                                                             |
|o8 = X                                                                       |
|                                                                             |
|o8 : a flag bundle with subquotient ranks {2:1}                              |
+-----------------------------------------------------------------------------+
|i9 : Y = abstractProjectiveSpace(3, B)                                       |
|                                                                             |
|o9 = Y                                                                       |
|                                                                             |
|o9 : a flag bundle with subquotient ranks {1, 3}                             |
+-----------------------------------------------------------------------------+
|i10 : i = map(Y,X,OO_X(3)) --includes P^1 into P^3 as the twisted cubic      |
|                                                                             |
|o10 = i                                                                      |
|                                                                             |
|o10 : a map to Y from X                                                      |
+-----------------------------------------------------------------------------+
|i11 : (Ytilde, PN, PNmap, Ymap) = blowup(i)                                  |
|                                                                             |
|o11 = (Ytilde, PN, PNmap, Ymap)                                              |
|                                                                             |
|o11 : Sequence                                                               |
+-----------------------------------------------------------------------------+
|i12 : Ediv = chern(1, exceptionalDivisor Ytilde)                             |
|                                                                             |
|o12 = E                                                                      |
|       0                                                                     |
|                                                                             |
|                      QQ[r..t][h, H   ..H   ]                                |
|                                   2,1   2,3                                 |
|      -------------------------------------------------------[E ]            |
|      (- h - H   , - h*H    - H   , - h*H    - H   , -h*H   )  0             |
|              2,1       2,1    2,2       2,2    2,3      2,3                 |
|o12 : -----------------------------------------------------------            |
|                                   2                                         |
|                (H   E , H   E , 3E  - 10H   E  + 9H   )                     |
|                  2,2 0   2,3 0    0      2,1 0     2,2                      |
+-----------------------------------------------------------------------------+
|i13 : hyperplane = chern(1,OO_Y(1))                                          |
|                                                                             |
|o13 = H                                                                      |
|       2,1                                                                   |
|                                                                             |
|                      QQ[r..t][h, H   ..H   ]                                |
|                                   2,1   2,3                                 |
|o13 : -------------------------------------------------------                |
|      (- h - H   , - h*H    - H   , - h*H    - H   , -h*H   )                |
|              2,1       2,1    2,2       2,2    2,3      2,3                 |
+-----------------------------------------------------------------------------+
|i14 : (rsurf, ssurf, tsurf) = (x -> hyperplane * x) \ (r,s,t) --classes of   |
|                                                                             |
|o14 = (r*H   , s*H   , t*H   )                                               |
|          2,1     2,1     2,1                                                |
|                                                                             |
|o14 : Sequence                                                               |
|-----------------------------------------------------------------------------|
|surfaces of degrees r,s,t                                                    |
+-----------------------------------------------------------------------------+
|i15 : (ptr, pts, ptt) = (x -> (Ymap^* x) - Ediv) \ oo --proper transforms of |
|                                                                             |
|o15 = (- E  + r*H   , - E  + s*H   , - E  + t*H   )                          |
|          0      2,1     0      2,1     0      2,1                           |
|                                                                             |
|o15 : Sequence                                                               |
|-----------------------------------------------------------------------------|
|each surface                                                                 |
+-----------------------------------------------------------------------------+
|i16 : integral(ptr * pts * ptt)                                              |
|                                                                             |
|o16 = r*s*t - 3r - 3s - 3t + 10                                              |
|                                                                             |
|o16 : QQ[r..t]                                                               |
+-----------------------------------------------------------------------------+

The file Schubert2/blowup-test.m2 has several more examples.

See also
========

  * exceptionalDivisor -- get the exceptional
    divisor of a blowup

Ways to use blowup:
===================

  * "blowup(AbstractVarietyMap)"

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

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

BundleRanks -- get the ranks of the tautological sheaves on a flag bundle
*************************************************************************

Synopsis
========

  * Usage:
        F.BundleRanks
  * Inputs:
      * F, an abstract flag bundle,
  * Outputs:
      * a list (Macaulay2Doc), the list of ranks of the
        tautological sheaves on $F$

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

+------------------------------------------------+
|i1 : G = abstractProjectiveSpace 7              |
|                                                |
|o1 = G                                          |
|                                                |
|o1 : a flag bundle with subquotient ranks {1, 7}|
+------------------------------------------------+
|i2 : G.BundleRanks                              |
|                                                |
|o2 = {1, 7}                                     |
|                                                |
|o2 : List                                       |
+------------------------------------------------+
|i3 : X = flagBundle {1,2,3}                     |
|                                                |
|o3 = X                                          |
|                                                |
|o3 : a flag bundle with subquotient ranks {1..3}|
+------------------------------------------------+
|i4 : X.BundleRanks                              |
|                                                |
|o4 = {1, 2, 3}                                  |
|                                                |
|o4 : List                                       |
+------------------------------------------------+

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

The object BundleRanks, is a symbol (Macaulay2Doc).

Bundles -- a symbol used internally as a key
********************************************

Synopsis
========

  * Usage:
        F.Bundles
  * Inputs:
      * F, an abstract flag bundle,
  * Outputs:
      * a sequence (Macaulay2Doc), the list of the tautological
        sheaves on $F$

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

The preferred way to get the list of tautological sheaves on $F$ is bundles F.

+------------------------------------------------+
|i1 : G = abstractProjectiveSpace 7              |
|                                                |
|o1 = G                                          |
|                                                |
|o1 : a flag bundle with subquotient ranks {1, 7}|
+------------------------------------------------+
|i2 : G.Bundles                                  |
|                                                |
|o2 = (a sheaf, a sheaf)                         |
|                                                |
|o2 : Sequence                                   |
+------------------------------------------------+
|i3 : rank \ oo                                  |
|                                                |
|o3 = (1, 7)                                     |
|                                                |
|o3 : Sequence                                   |
+------------------------------------------------+
|i4 : X = flagBundle {1,2,3}                     |
|                                                |
|o4 = X                                          |
|                                                |
|o4 : a flag bundle with subquotient ranks {1..3}|
+------------------------------------------------+
|i5 : X.Bundles                                  |
|                                                |
|o5 = (a sheaf, a sheaf, a sheaf)                |
|                                                |
|o5 : Sequence                                   |
+------------------------------------------------+
|i6 : rank \ oo                                  |
|                                                |
|o6 = (1, 2, 3)                                  |
|                                                |
|o6 : Sequence                                   |
+------------------------------------------------+

See also
========

  * bundles -- get the list of tautological line bundles on a
    flag bundle

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

The object Bundles, is a symbol (Macaulay2Doc).

bundles -- get the list of tautological line bundles on a flag bundle
*********************************************************************

Synopsis
========

  * Usage:
        bundles X
  * Inputs:
      * X, an abstract flag bundle,
  * Outputs:
      * a list (Macaulay2Doc), of bundles, the tautological bundles
        on the flagBundle X

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

+------------------------------------------------+
|i1 : X = flagBundle({2,3,4})                    |
|                                                |
|o1 = X                                          |
|                                                |
|o1 : a flag bundle with subquotient ranks {2..4}|
+------------------------------------------------+
|i2 : L = bundles X                              |
|                                                |
|o2 = (a sheaf, a sheaf, a sheaf)                |
|                                                |
|o2 : Sequence                                   |
+------------------------------------------------+
|i3 : rank \ L                                   |
|                                                |
|o3 = (2, 3, 4)                                  |
|                                                |
|o3 : Sequence                                   |
+------------------------------------------------+

Ways to use bundles:
====================

  * "bundles(FlagBundle)"

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

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

ch -- Chern character of an abstract sheaf
******************************************

Ways to use ch:
===============

  * ch(AbstractSheaf) -- total Chern character of
    an abstract sheaf
  * ch(ZZ,AbstractSheaf) -- the i-th Chern
    character of an abstract sheaf

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

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

ch(AbstractSheaf) -- total Chern character of an abstract sheaf
***************************************************************

Synopsis
========

  * Function: ch,
  * Usage:
        ch F
  * Inputs:
      * F,
  * Outputs:
      * the total Chern character of $F$

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

+---------------------------------------------------------+
|i1 : X = abstractProjectiveSpace' 3                      |
|                                                         |
|o1 = X                                                   |
|                                                         |
|o1 : a flag bundle with subquotient ranks {3, 1}         |
+---------------------------------------------------------+
|i2 : L = OO_X(1)                                         |
|                                                         |
|o2 = L                                                   |
|                                                         |
|o2 : an abstract sheaf of rank 1 on X                    |
+---------------------------------------------------------+
|i3 : chern L                                             |
|                                                         |
|o3 = 1 + h                                               |
|                                                         |
|                      QQ[][H   ..H   , h]                |
|                            1,1   1,3                    |
|o3 : ----------------------------------------------------|
|     (- H    - h, - H    - H   h, - H    - H   h, -H   h)|
|         1,1         1,2    1,1      1,3    1,2     1,3  |
+---------------------------------------------------------+
|i4 : ch L                                                |
|                                                         |
|             1 2   1 3                                   |
|o4 = 1 + h + -h  + -h                                    |
|             2     6                                     |
|                                                         |
|                      QQ[][H   ..H   , h]                |
|                            1,1   1,3                    |
|o4 : ----------------------------------------------------|
|     (- H    - h, - H    - H   h, - H    - H   h, -H   h)|
|         1,1         1,2    1,1      1,3    1,2     1,3  |
+---------------------------------------------------------+

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

  * ch(AbstractSheaf) -- total Chern character of
    an abstract sheaf

ch(ZZ,AbstractSheaf) -- the i-th Chern character of an abstract sheaf
*********************************************************************

Synopsis
========

  * Function: ch,
  * Usage:
        ch F
  * Inputs:
      * i,
      * F,
  * Outputs:
      * the $i$-th Chern character of $F$

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

+---------------------------------------------------------+
|i1 : X = abstractProjectiveSpace' 3                      |
|                                                         |
|o1 = X                                                   |
|                                                         |
|o1 : a flag bundle with subquotient ranks {3, 1}         |
+---------------------------------------------------------+
|i2 : L = OO_X(1)                                         |
|                                                         |
|o2 = L                                                   |
|                                                         |
|o2 : an abstract sheaf of rank 1 on X                    |
+---------------------------------------------------------+
|i3 : chern L                                             |
|                                                         |
|o3 = 1 + h                                               |
|                                                         |
|                      QQ[][H   ..H   , h]                |
|                            1,1   1,3                    |
|o3 : ----------------------------------------------------|
|     (- H    - h, - H    - H   h, - H    - H   h, -H   h)|
|         1,1         1,2    1,1      1,3    1,2     1,3  |
+---------------------------------------------------------+
|i4 : ch_1 L, ch_2 L, ch_3 L                              |
|                                                         |
|         1 2  1 3                                        |
|o4 = (h, -h , -h )                                       |
|         2    6                                          |
|                                                         |
|o4 : Sequence                                            |
+---------------------------------------------------------+

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

  * ch(ZZ,AbstractSheaf) -- the i-th Chern
    character of an abstract sheaf

chern -- compute Chern classes of a sheaf
*****************************************

Ways to use chern:
==================

  * chern(AbstractSheaf) -- compute the total
    Chern class of a sheaf
  * chern(ZZ,AbstractSheaf) -- compute a
    Chern class of a sheaf
  * chern(ZZ,ChernClassVariableTable)
    -- get value of a Chern class
    variable
  * chern(ZZ,Symbol) -- make a Chern class
    symbol
  * chern(ZZ,ZZ,AbstractSheaf), --
    compute several Chern classes of an abstract sheaf

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

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

chern(AbstractSheaf) -- compute the total Chern class of a sheaf
****************************************************************

Synopsis
========

  * Function: chern,
  * Usage:
        chern A
  * Inputs:
      * A,
  * Outputs:
      * the total Chern class of A

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

+--------------------------------------------------+
|i1 : base(3, Bundle => (A,2,a), Bundle => (B,3,b))|
|                                                  |
|o1 = a variety                                    |
|                                                  |
|o1 : an abstract variety of dimension 3           |
+--------------------------------------------------+
|i2 : chern B                                      |
|                                                  |
|o2 = 1 + b  + b  + b                              |
|          1    2    3                             |
|                                                  |
|o2 : QQ[a ..a , b ..b ]                           |
|         1   2   1   3                            |
+--------------------------------------------------+
|i3 : chern(-A)                                    |
|                                                  |
|                2             3                   |
|o3 = 1 - a  + (a  - a ) + (- a  + 2a a )          |
|          1     1    2        1     1 2           |
|                                                  |
|o3 : QQ[a ..a , b ..b ]                           |
|         1   2   1   3                            |
+--------------------------------------------------+

The next example gives the total Chern class of a twist of a rank 2 vector
bundle on the projective plane.

+------------------------------------------------------------+
|i4 : pt = base(n,p,q)                                       |
|                                                            |
|o4 = pt                                                     |
|                                                            |
|o4 : an abstract variety of dimension 0                     |
+------------------------------------------------------------+
|i5 : P2 = abstractProjectiveSpace'_2 pt                     |
|                                                            |
|o5 = P2                                                     |
|                                                            |
|o5 : a flag bundle with subquotient ranks {2, 1}            |
+------------------------------------------------------------+
|i6 : E = abstractSheaf(P2, Rank=>2, ChernClass=>1+p*h+q*h^2)|
|                                                            |
|o6 = E                                                      |
|                                                            |
|o6 : an abstract sheaf of rank 2 on P2                      |
+------------------------------------------------------------+
|i7 : chern E(n*h)                                           |
|                                                            |
|                       2            2                       |
|o7 = 1 + (2n + p)h + (n  + n*p + q)h                        |
|                                                            |
|          QQ[n, p..q][H   ..H   , h]                        |
|                       1,1   1,2                            |
|o7 : ------------------------------------                   |
|     (- H    - h, - H    - H   h, -H   h)                   |
|         1,1         1,2    1,1     1,2                     |
+------------------------------------------------------------+

See also
========

  * segre -- compute Segre classes of a sheaf

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

  * chern(AbstractSheaf) -- compute the total
    Chern class of a sheaf

chern(ZZ,AbstractSheaf) -- compute a Chern class of a sheaf
***********************************************************

Synopsis
========

  * Function: chern,
  * Usage:
        chern(n,A)
        chern_n A
  * Inputs:
      * n,
      * A,
  * Outputs:
      * the n-th Chern class of A

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

+--------------------------------------------------+
|i1 : base(3, Bundle => (A,2,a), Bundle => (B,3,b))|
|                                                  |
|o1 = a variety                                    |
|                                                  |
|o1 : an abstract variety of dimension 3           |
+--------------------------------------------------+
|i2 : chern_3 B                                    |
|                                                  |
|o2 = b                                            |
|      3                                           |
|                                                  |
|o2 : QQ[a ..a , b ..b ]                           |
|         1   2   1   3                            |
+--------------------------------------------------+
|i3 : chern(2,A**B)                                |
|                                                  |
|       2                  2                       |
|o3 = 3a  + 3a  + 5a b  + b  + 2b                  |
|       1     2     1 1    1     2                 |
|                                                  |
|o3 : QQ[a ..a , b ..b ]                           |
|         1   2   1   3                            |
+--------------------------------------------------+

See also
========

  * segre(ZZ,AbstractSheaf) -- compute a
    Segre class of a sheaf

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

  * chern(ZZ,AbstractSheaf) -- compute a
    Chern class of a sheaf

chern(ZZ,ChernClassVariableTable) -- get value of a Chern class variable
************************************************************************

Synopsis
========

  * Function: chern,
  * Usage:
        chern_i E
  * Inputs:
      * i,
      * E,
  * Outputs:
      * the value of the Chern class variable chern_i E

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

+----------------------------+
|i1 : chern_3 E <- 44        |
|                            |
|o1 = 44                     |
+----------------------------+
|i2 : E                      |
|                            |
|o2 = E                      |
|                            |
|o2 : ChernClassVariableTable|
+----------------------------+
|i3 : chern_3 E              |
|                            |
|o3 = 44                     |
+----------------------------+

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

  * chern(ZZ,ChernClassVariableTable)
    -- get value of a Chern class
    variable

chern(ZZ,Symbol) -- make a Chern class symbol
*********************************************

Synopsis
========

  * Function: chern,
  * Usage:
        chern(i,E)
        chern_i E
  * Inputs:
      * i,
      * E,
  * Outputs:
      * based on i and on E

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

+-----------------------+
|i1 : chern_3 E         |
|                       |
|o1 = c E               |
|      3                |
|                       |
|o1 : ChernClassVariable|
+-----------------------+

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

  * chern(ZZ,Symbol) -- make a Chern class
    symbol

chern(ZZ,ZZ,AbstractSheaf) -- compute several Chern classes of an abstract sheaf
********************************************************************************

Synopsis
========

  * Function: chern,
  * Usage:
        chern(n,m,A)
  * Inputs:
      * n,
      * m,
      * A,
  * Outputs:
      * a list (Macaulay2Doc), the list $ \{ c_n A .. c_m A \} $ of
        Chern classes of $A$

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

In the following example, we consider two vector bundles A and B of ranks 2 and
3 on a variety of dimension 4.

+------------------------------------------------------------+
|i1 : base(4,Bundle => (A,2,a), Bundle => (B,3,b))           |
|                                                            |
|o1 = a variety                                              |
|                                                            |
|o1 : an abstract variety of dimension 4                     |
+------------------------------------------------------------+
|i2 : netList chern(2,4,B-A)                                 |
|                                                            |
|     +-----------------------------------------------------+|
|     | 2                                                   ||
|o2 = |a  - a  - a b  + b                                   ||
|     | 1    2    1 1    2                                  ||
|     +-----------------------------------------------------+|
|     |   3            2                                    ||
|     |- a  + 2a a  + a b  - a b  - a b  + b                ||
|     |   1     1 2    1 1    2 1    1 2    3               ||
|     +-----------------------------------------------------+|
|     | 4     2      2    3                2                ||
|     |a  - 3a a  + a  - a b  + 2a a b  + a b  - a b  - a b ||
|     | 1     1 2    2    1 1     1 2 1    1 2    2 2    1 3||
|     +-----------------------------------------------------+|
+------------------------------------------------------------+

See also
========

  * base -- make an abstract variety from nothing, equipped with
    some parameters and some bundles
  * netList (Macaulay2Doc) -- a table of boxes

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

  * chern(ZZ,ZZ,AbstractSheaf), --
    compute several Chern classes of an abstract sheaf

ChernClassVariable -- the class of all Chern class variables
************************************************************

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

This class supports the creation of variables, analogous to indexed variables (Macaulay2Doc),
that can be used as generators of
intersection rings of abstract varieties that are displayed in the form c_iE,
where i is a natural number and E is the name of an abstract sheaf.

+-----------------------------------------------------------------------------+
|i1 : F = flagBundle({3,2},VariableNames => {{chern_1 S .. chern_3 S},{chern_1|
|                                                                             |
|o1 = F                                                                       |
|                                                                             |
|o1 : a flag bundle with subquotient ranks {3, 2}                             |
|-----------------------------------------------------------------------------|
|Q,chern_2 Q}})                                                               |
+-----------------------------------------------------------------------------+
|i2 : A = intersectionRing F                                                  |
|                                                                             |
|o2 = A                                                                       |
|                                                                             |
|o2 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i3 : (S,Q) = bundles F                                                       |
|                                                                             |
|o3 = (S, Q)                                                                  |
|                                                                             |
|o3 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i4 : chern Q                                                                 |
|                                                                             |
|o4 = 1 + c Q + c Q                                                           |
|          1     2                                                            |
|                                                                             |
|o4 : A                                                                       |
+-----------------------------------------------------------------------------+
|i5 : chern S                                                                 |
|                                                                             |
|                     2                  3                                    |
|o5 = 1 - c Q + ((c Q)  - c Q) + (- (c Q)  + 2*c Q*c Q)                       |
|          1       1       2          1         1   2                         |
|                                                                             |
|o5 : A                                                                       |
+-----------------------------------------------------------------------------+

See also
========

  * ChernClassVariableTable -- the class of all
    Chern class variable tables

Functions and methods returning a Chern class variable:
=======================================================

  * chern(ZZ,Symbol) -- make a Chern class
    symbol

Methods that use a Chern class variable:
========================================

  * ChernClassVariable .. ChernClassVariable
    -- generate a sequence of Chern class variables
  * ChernClassVariable <- Thing, --
    assignment to a Chern class variable
  * Ring _ ChernClassVariable -- get a ring
    generator corresponding to a Chern class variable
  * value(ChernClassVariable) -- the
    value of a Chern class symbol

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

The object ChernClassVariable, is a type (Macaulay2Doc),
with ancestor classes BasicList (Macaulay2Doc),
< Thing (Macaulay2Doc).

ChernClassVariable .. ChernClassVariable -- generate a sequence of Chern class variables
****************************************************************************************

Synopsis
========

  * Operator: .. (Macaulay2Doc),
  * Usage:
        v .. w
  * Inputs:
      * v, equal to chern_i E, say
      * w, equal to chern_j E, say
  * Outputs:
      * a sequence (Macaulay2Doc), the sequence whose elements
        are the Chern class variables chern_k E as k ranges from i to j

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

+--------------------------------------------------------+
|i1 : chern_1 E .. chern_10 E                            |
|                                                        |
|o1 = (c E, c E, c E, c E, c E, c E, c E, c E, c E, c  E)|
|       1    2    3    4    5    6    7    8    9    10  |
|                                                        |
|o1 : Sequence                                           |
+--------------------------------------------------------+

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

  * ChernClassVariable .. ChernClassVariable
    -- generate a sequence of Chern class variables

ChernClassVariable <- Thing -- assignment to a Chern class variable
*******************************************************************

Synopsis
========

  * Operator: <- (Macaulay2Doc),
  * Usage:
        v <- x
  * Inputs:
      * v,
      * x,
  * Outputs:
      * x
  * Consequences:
      * x is assigned to the variable v

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

This intended for internal use by Schubert2.

+-----------------------+
|i1 : chern_3 E         |
|                       |
|o1 = c E               |
|      3                |
|                       |
|o1 : ChernClassVariable|
+-----------------------+
|i2 : chern_3 E <- 444  |
|                       |
|o2 = 444               |
+-----------------------+
|i3 : chern_3 E         |
|                       |
|o3 = 444               |
+-----------------------+

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

  * ChernClassVariable <- Thing, --
    assignment to a Chern class variable

ChernClassVariableTable -- the class of all Chern class variable tables
***********************************************************************

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

After creating a Chern class variable such as chern_3 E, the base symbol E
acquires as value a hash table that holds the values of the Chern class
variables based on it.  If something else is assigned to E, the values are no
longer referred to by E, and will the space they occupy be collected and reused
unless other references to them remain.

+-----------------------------------------------------------------------------+
|i1 : chern_3 E                                                               |
|                                                                             |
|o1 = c E                                                                     |
|      3                                                                      |
|                                                                             |
|o1 : ChernClassVariable                                                      |
+-----------------------------------------------------------------------------+
|i2 : E                                                                       |
|                                                                             |
|o2 = E                                                                       |
|                                                                             |
|o2 : ChernClassVariableTable                                                 |
+-----------------------------------------------------------------------------+
|i3 : peek E                                                                  |
|                                                                             |
|o3 = ChernClassVariableTable{symbol$ => E}                                   |
+-----------------------------------------------------------------------------+
|i4 : chern_3 symbol E <- 44                                                  |
|                                                                             |
|o4 = 44                                                                      |
+-----------------------------------------------------------------------------+
|i5 : chern_3 E                                                               |
|                                                                             |
|o5 = 44                                                                      |
+-----------------------------------------------------------------------------+
|i6 : peek E                                                                  |
|                                                                             |
|o6 = ChernClassVariableTable{3 => 44     }                                   |
|                             symbol$ => E                                    |
+-----------------------------------------------------------------------------+
|i7 : E = 55                                                                  |
|                                                                             |
|o7 = 55                                                                      |
+-----------------------------------------------------------------------------+
|i8 : chern_3 symbol E <- 44                                                  |
|--warning: clearing value of symbol E to allow access to Chern class         |
|                                                                             |
|o8 = 44                                                                      |
|-----------------------------------------------------------------------------|
|variables based on it                                                        |
+-----------------------------------------------------------------------------+

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

  * chern(ZZ,ChernClassVariableTable)
    -- get value of a Chern class
    variable

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

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

chi(AbstractSheaf) -- compute the Euler characteristic of an abstract sheaf
***************************************************************************

Synopsis
========

  * Function: chi (Macaulay2Doc),
  * Usage:
        chi F
  * Inputs:
      * F,
  * Outputs:
      * the Euler characteristic of $F$

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

+---------------------------------------------------------------------+
|i1 : X = abstractProjectiveSpace' 2                                  |
|                                                                     |
|o1 = X                                                               |
|                                                                     |
|o1 : a flag bundle with subquotient ranks {2, 1}                     |
+---------------------------------------------------------------------+
|i2 : chi OO_X(-1), chi OO_X(0), chi OO_X(1), chi OO_X(2), chi OO_X(3)|
|                                                                     |
|o2 = (0, 1, 3, 6, 10)                                                |
|                                                                     |
|o2 : Sequence                                                        |
+---------------------------------------------------------------------+
|i3 : Y = abstractProjectiveSpace'(2, base n)                         |
|                                                                     |
|o3 = Y                                                               |
|                                                                     |
|o3 : a flag bundle with subquotient ranks {2, 1}                     |
+---------------------------------------------------------------------+
|i4 : chi OO_Y(n)                                                     |
|                                                                     |
|     1 2   3                                                         |
|o4 = -n  + -n + 1                                                    |
|     2     2                                                         |
|                                                                     |
|o4 : QQ[n]                                                           |
+---------------------------------------------------------------------+

The algorithm uses the Hirzebruch-Riemann-Roch theorem.

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

  * chi(AbstractSheaf) -- compute the Euler
    characteristic of an abstract sheaf

Correspondence -- the class of all correspondences
**************************************************

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

A correspondence $I$ from from an AbstractVariety, $X$
(the source (Macaulay2Doc), of $I$) to another AbstractVariety $Y$
(the target (Macaulay2Doc), of $I$) consists of two functions
$I_*$ and $I^*$, which take cycles on $X$ to cycles on $Y$ and vice-versa,
respectively.  In general these functions are not ring maps or even module
maps.  See Correspondence ^*, and
Correspondence _*, for more info.

Unlike an IncidenceCorrespondence, a general
Correspondence need not have an intermediate variety.

Types of Correspondence:
========================

  * IncidenceCorrespondence -- the class of all
    incidence correspondences

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

  * Correspondence * Correspondence,
    -- composition of correspondences
  * transpose(Correspondence) -- reverse
    the direction of a correspondence

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

  * Correspondence ^* -- pullback along a
    correspondence
  * Correspondence _* -- pushforward along a
    correspondence
  * source(Correspondence) -- the source of
    a correspondence
  * target(Correspondence) -- the target of
    a correspondence

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

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

Correspondence * Correspondence -- composition of correspondences
*****************************************************************

Synopsis
========

  * Operator: * (Macaulay2Doc),
  * Usage:
        J * I
  * Inputs:
      * I, an instance of the type Correspondence, from
        $X$ to $Y$
      * J, an instance of the type Correspondence, from
        $Y$ to $Z$
  * Outputs:
      * K, an instance of the type Correspondence, from
        $X$ to $Z$, such that $K_* = J_* I_*$ and $K^* = I^* J^*$

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

  * Correspondence * Correspondence,
    -- composition of correspondences

Correspondence ^* -- pullback along a correspondence
****************************************************

Synopsis
========

  * Operator: ^* (Macaulay2Doc),
  * Usage:
        I^*
  * Inputs:
      * I, from $X$ to $Y$
  * Outputs:
      * the pullback operator associated to $I$, which can be applied to
        abstract sheaves or cycles on $Y$

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

See incidenceCorrespondence, for an example of
the usage.

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

  * Correspondence ^* -- pullback along a
    correspondence

Correspondence _* -- pushforward along a correspondence
*******************************************************

Synopsis
========

  * Operator: _* (Macaulay2Doc),
  * Usage:
        I_*
  * Inputs:
      * I, from $X$ to $Y$
  * Outputs:
      * the pushforward operator associated to $I$, which can be applied to
        abstract sheaves or cycles on $X$

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

See incidenceCorrespondence, for an example of
the usage.

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

  * Correspondence _* -- pushforward along a
    correspondence

cotangentBundle -- get the cotangent bundle
*******************************************

Synopsis
========

  * Usage:
        cotangentBundle X
        cotangentBundle f
  * Inputs:
      * X, an abstract variety,
      * f, an abstract variety map,
  * Outputs:
      * an abstract sheaf, the (absolute) cotangent
        bundle of $X$ or the (relative) cotangent bundle of $f$

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

+--------------------------------------------------------------------+
|i1 : X = abstractProjectiveSpace' 2                                 |
|                                                                    |
|o1 = X                                                              |
|                                                                    |
|o1 : a flag bundle with subquotient ranks {2, 1}                    |
+--------------------------------------------------------------------+
|i2 : Y = abstractProjectiveSpace'_2 X                               |
|                                                                    |
|o2 = Y                                                              |
|                                                                    |
|o2 : a flag bundle with subquotient ranks {2, 1}                    |
+--------------------------------------------------------------------+
|i3 : cotangentBundle Y                                              |
|                                                                    |
|o3 = a sheaf                                                        |
|                                                                    |
|o3 : an abstract sheaf of rank 4 on Y                               |
+--------------------------------------------------------------------+
|i4 : chern oo                                                       |
|                                                                    |
|                          2            2           2     2       2 2|
|o4 = 1 + (- 3h - 3h) + (3h  + 9h*h + 3h ) + (- 9h*h  - 9h h) + 9h h |
|                                                                    |
|              QQ[][H   ..H   , h]                                   |
|                    1,1   1,2                                       |
|     ------------------------------------[H   ..H   , h]            |
|     (- H    - h, - H    - H   h, -H   h)  1,1   1,2                |
|         1,1         1,2    1,1     1,2                             |
|o4 : ---------------------------------------------------            |
|             (- H    - h, - H    - H   h, -H   h)                   |
|                 1,1         1,2    1,1     1,2                     |
+--------------------------------------------------------------------+
|i5 : cotangentBundle Y.StructureMap                                 |
|                                                                    |
|o5 = a sheaf                                                        |
|                                                                    |
|o5 : an abstract sheaf of rank 2 on Y                               |
+--------------------------------------------------------------------+
|i6 : chern oo                                                       |
|                                                                    |
|                2                                                   |
|o6 = 1 - 3h + 3h                                                    |
|                                                                    |
|              QQ[][H   ..H   , h]                                   |
|                    1,1   1,2                                       |
|     ------------------------------------[H   ..H   , h]            |
|     (- H    - h, - H    - H   h, -H   h)  1,1   1,2                |
|         1,1         1,2    1,1     1,2                             |
|o6 : ---------------------------------------------------            |
|             (- H    - h, - H    - H   h, -H   h)                   |
|                 1,1         1,2    1,1     1,2                     |
+--------------------------------------------------------------------+

See also
========

  * tangentBundle -- get the tangent bundle

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

  * "cotangentBundle(AbstractVariety)"
  * "cotangentBundle(AbstractVarietyMap)"

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

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

ctop(AbstractSheaf) -- the top Chern class of an abstract sheaf
***************************************************************

Synopsis
========

  * Function: ctop,
  * Usage:
        ctop F
  * Inputs:
      * F,
  * Outputs:
      * the top Chern class of $F$

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

Here we compute the top Chern class of a vector bundle of rank 6 on the way
toward getting the number of lines on quintic threefold.

+-----------------------------------------------------------------------------+
|i1 : G = flagBundle{3,2}                                                     |
|                                                                             |
|o1 = G                                                                       |
|                                                                             |
|o1 : a flag bundle with subquotient ranks {3, 2}                             |
+-----------------------------------------------------------------------------+
|i2 : B = symmetricPower_5 last bundles G                                     |
|                                                                             |
|o2 = B                                                                       |
|                                                                             |
|o2 : an abstract sheaf of rank 6 on G                                        |
+-----------------------------------------------------------------------------+
|i3 : ctop B                                                                  |
|                                                                             |
|          3                                                                  |
|o3 = 2875H                                                                   |
|          2,2                                                                |
|                                                                             |
|                                            QQ[][H   ..H   , H   ..H   ]     |
|                                                  1,1   1,3   2,1   2,2      |
|o3 : ------------------------------------------------------------------------|
|     (- H    - H   , - H    - H   H    - H   , - H    - H   H    - H   H   , |
|         1,1    2,1     1,2    1,1 2,1    2,2     1,3    1,2 2,1    1,1 2,2  |
|-----------------------------------------------------------------------------|
|---------------------------------                                            |
|- H   H    - H   H   , -H   H   )                                            |
|   1,3 2,1    1,2 2,2    1,3 2,2                                             |
+-----------------------------------------------------------------------------+
|i4 : degree oo                                                               |
|                                                                             |
|o4 = {6}                                                                     |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : integral ooo                                                            |
|                                                                             |
|o5 = 2875                                                                    |
+-----------------------------------------------------------------------------+

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

  * ctop(AbstractSheaf) -- the top Chern class
    of an abstract sheaf

degeneracyLocus(ZZ,AbstractSheaf,AbstractSheaf)
***********************************************

Synopsis
========

  * Function: degeneracyLocus,
  * Usage:
        degeneracyLocus(k,B,A)
  * Inputs:
      * k,
      * B,
      * A,
  * Outputs:
      * the locus where the rank of a generic map from A to B is at most k

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

+------------------------------------------------------+
|i1 : X = base(5, Bundle => (A,3,a), Bundle => (B,3,b))|
|                                                      |
|o1 = X                                                |
|                                                      |
|o1 : an abstract variety of dimension 5               |
+------------------------------------------------------+
|i2 : Z = degeneracyLocus(2,B,A)                       |
|                                                      |
|o2 = Z                                                |
|                                                      |
|o2 : an abstract variety of dimension 4               |
+------------------------------------------------------+
|i3 : Z/X                                              |
|                                                      |
|o3 = a variety map                                    |
|                                                      |
|o3 : a map to X from Z                                |
+------------------------------------------------------+
|i4 : (Z/X)_* 1                                        |
|                                                      |
|o4 = - a  + b                                         |
|        1    1                                        |
|                                                      |
|o4 : QQ[a ..b ]                                       |
|         1   3                                        |
+------------------------------------------------------+

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

  * degeneracyLocus(ZZ,AbstractSheaf,AbstractSheaf)

degeneracyLocus2(ZZ,AbstractSheaf,AbstractSheaf)
************************************************

Synopsis
========

  * Function: degeneracyLocus2,
  * Usage:
        degeneracyLocus2(k,B,A)
  * Inputs:
      * k,
      * B,
      * A,
  * Outputs:
      * the cycle class of the locus where the rank of a generic map from A to
        B is at most k

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

+-----------------------------------------------------------------------------+
|i1 : X = base(5, Bundle => (L,1,{l}), Bundle => (M,1,{m}), Bundle =>         |
|                                                                             |
|o1 = X                                                                       |
|                                                                             |
|o1 : an abstract variety of dimension 5                                      |
|-----------------------------------------------------------------------------|
|(N,1,{n}))                                                                   |
+-----------------------------------------------------------------------------+
|i2 : degeneracyLocus2(0,L+M+N,OO_X)                                          |
|                                                                             |
|o2 = l*m*n                                                                   |
|                                                                             |
|o2 : QQ[l..n]                                                                |
+-----------------------------------------------------------------------------+
|i3 : degeneracyLocus2(1,L+M+N,2*OO_X)                                        |
|                                                                             |
|o3 = l*m + l*n + m*n                                                         |
|                                                                             |
|o3 : QQ[l..n]                                                                |
+-----------------------------------------------------------------------------+
|i4 : degeneracyLocus2(2,L+M+N,3*OO_X)                                        |
|                                                                             |
|o4 = l + m + n                                                               |
|                                                                             |
|o4 : QQ[l..n]                                                                |
+-----------------------------------------------------------------------------+
|i5 : X = base(5, Bundle => (A,3,a), Bundle => (B,3,b))                       |
|                                                                             |
|o5 = X                                                                       |
|                                                                             |
|o5 : an abstract variety of dimension 5                                      |
+-----------------------------------------------------------------------------+
|i6 : degeneracyLocus2(0,B,OO_X)                                              |
|                                                                             |
|o6 = b                                                                       |
|      3                                                                      |
|                                                                             |
|o6 : QQ[a ..b ]                                                              |
|         1   3                                                               |
+-----------------------------------------------------------------------------+
|i7 : degeneracyLocus2(1,B,2*OO_X)                                            |
|                                                                             |
|o7 = b                                                                       |
|      2                                                                      |
|                                                                             |
|o7 : QQ[a ..b ]                                                              |
|         1   3                                                               |
+-----------------------------------------------------------------------------+
|i8 : degeneracyLocus2(2,B,3*OO_X)                                            |
|                                                                             |
|o8 = b                                                                       |
|      1                                                                      |
|                                                                             |
|o8 : QQ[a ..b ]                                                              |
|         1   3                                                               |
+-----------------------------------------------------------------------------+
|i9 : degeneracyLocus2(1,B,A)                                                 |
|                                                                             |
|      2                             2    2                       2           |
|o9 = a  - a a  - a a b  + a b  + a b  + a b  - 2a b  - a b b  + b  + a b  -  |
|      2    1 3    1 2 1    3 1    2 1    1 2     2 2    1 1 2    2    1 3    |
|     ------------------------------------------------------------------------|
|     b b                                                                     |
|      1 3                                                                    |
|                                                                             |
|o9 : QQ[a ..b ]                                                              |
|         1   3                                                               |
+-----------------------------------------------------------------------------+
|i10 : degeneracyLocus2(2,B,A)                                                |
|                                                                             |
|o10 = - a  + b                                                               |
|         1    1                                                              |
|                                                                             |
|o10 : QQ[a ..b ]                                                             |
|          1   3                                                              |
+-----------------------------------------------------------------------------+
|i11 : degeneracyLocus2(3,B,A)                                                |
|                                                                             |
|o11 = 1                                                                      |
|                                                                             |
|o11 : QQ[a ..b ]                                                             |
|          1   3                                                              |
+-----------------------------------------------------------------------------+

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

  * degeneracyLocus2(ZZ,AbstractSheaf,AbstractSheaf)

determinant(AbstractSheaf) -- determinant of an abstract sheaf
**************************************************************

Synopsis
========

  * Function: determinant (Macaulay2Doc),
  * Usage:
        det F
  * Inputs:
      * F,
  * Optional inputs (Macaulay2Doc),:
      * Strategy (Macaulay2Doc),
        => ..., default value null,
  * Outputs:
      * the determinant of F

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

The determinant of F is the $n$-th exterior power of F, where $n$ is the rank
of F.

+-----------------------------------------------+
|i1 : X = abstractProjectiveSpace 1             |
|                                               |
|o1 = X                                         |
|                                               |
|o1 : a flag bundle with subquotient ranks {2:1}|
+-----------------------------------------------+
|i2 : F = OO_X(1) ++ OO_X(1) ++ OO_X(3)         |
|                                               |
|o2 = F                                         |
|                                               |
|o2 : an abstract sheaf of rank 3 on X          |
+-----------------------------------------------+
|i3 : det F                                     |
|                                               |
|o3 = a sheaf                                   |
|                                               |
|o3 : an abstract sheaf of rank 1 on X          |
+-----------------------------------------------+
|i4 : chern oo                                  |
|                                               |
|o4 = 1 + 5H                                    |
|           2,1                                 |
|                                               |
|         QQ[][h, H   ]                         |
|                  2,1                          |
|o4 : ---------------------                     |
|     (- h - H   , -h*H   )                     |
|             2,1      2,1                      |
+-----------------------------------------------+
|i5 : rank ooo                                  |
|                                               |
|o5 = 1                                         |
+-----------------------------------------------+

See also
========

  * exteriorPower(ZZ,AbstractSheaf)

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

  * determinant(AbstractSheaf), --
    determinant of an abstract sheaf

dim(AbstractVariety) -- the dimension of an abstract variety
************************************************************

Synopsis
========

  * Function: dim (Macaulay2Doc),
  * Usage:
        dim X
  * Inputs:
      * X,
  * Outputs:
      * the dimension of X

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

+----------------------------------+
|i1 : dim abstractProjectiveSpace 4|
|                                  |
|o1 = 4                            |
+----------------------------------+

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

  * dim(AbstractVariety) -- the dimension of
    an abstract variety

dim(AbstractVarietyMap) -- the dimension of an abstract variety
***************************************************************

Synopsis
========

  * Function: dim (Macaulay2Doc),
  * Usage:
        dim X
  * Inputs:
      * X,
  * Outputs:
      * the dimension X

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

+----------------------------------+
|i1 : dim abstractProjectiveSpace 4|
|                                  |
|o1 = 4                            |
+----------------------------------+

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

  * dim(AbstractVarietyMap) -- the
    dimension of an abstract variety

dual(AbstractSheaf) -- the dual of an abstract sheaf
****************************************************

Synopsis
========

  * Function: dual (Macaulay2Doc),
  * Usage:
        dual F
  * Inputs:
      * F,
  * Outputs:
      * the dual of F

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

+-----------------------------------------------+
|i1 : X = abstractProjectiveSpace' 1            |
|                                               |
|o1 = X                                         |
|                                               |
|o1 : a flag bundle with subquotient ranks {2:1}|
+-----------------------------------------------+
|i2 : dual OO_X(-1)                             |
|                                               |
|o2 = a sheaf                                   |
|                                               |
|o2 : an abstract sheaf of rank 1 on X          |
+-----------------------------------------------+
|i3 : chi oo                                    |
|                                               |
|o3 = 2                                         |
+-----------------------------------------------+

See also
========

  * Hom(AbstractSheaf,AbstractSheaf)
    -- Hom between abstract sheaves

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

  * dual(AbstractSheaf) -- the dual of an
    abstract sheaf

euler(AbstractVariety)
**********************

Synopsis
========

  * Function: euler (Varieties),
  * Usage:
        euler X
  * Inputs:
      * X,
  * Outputs:
      * an integer (Macaulay2Doc), the topological Euler
        characteristic of the variety X

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

+------------------------------------+
|i1 : euler abstractProjectiveSpace 5|
|                                    |
|o1 = 6                              |
+------------------------------------+
|i2 : euler flagBundle {1,1,1,1,1}   |
|                                    |
|o2 = 120                            |
+------------------------------------+

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

  * euler(AbstractVariety)

exceptionalDivisor -- get the exceptional divisor of a blowup
*************************************************************

Synopsis
========

  * Usage:
        exceptionalDivisor X
  * Inputs:
      * X, an abstract variety, a blowup, built using
        blowup,
  * Outputs:
      * an abstract sheaf, the exceptional divisor on X,
        expressed as a line bundle

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

+-----------------------------------------------------+
|i1 : T = abstractProjectiveSpace 2                   |
|                                                     |
|o1 = T                                               |
|                                                     |
|o1 : a flag bundle with subquotient ranks {1..2}     |
+-----------------------------------------------------+
|i2 : S = abstractProjectiveSpace 0                   |
|                                                     |
|o2 = S                                               |
|                                                     |
|o2 : a flag bundle with subquotient ranks {1, 0}     |
+-----------------------------------------------------+
|i3 : i = map(T,S,OO_S) -- inclusion of a point in P^2|
|                                                     |
|o3 = i                                               |
|                                                     |
|o3 : a map to T from S                               |
+-----------------------------------------------------+
|i4 : X = first blowup(i)                             |
|                                                     |
|o4 = X                                               |
|                                                     |
|o4 : an abstract variety of dimension 2              |
+-----------------------------------------------------+
|i5 : exceptionalDivisor X                            |
|                                                     |
|o5 = a sheaf                                         |
|                                                     |
|o5 : an abstract sheaf of rank 1 on X                |
+-----------------------------------------------------+
|i6 : chern oo                                        |
|                                                     |
|o6 = 1 + E                                           |
|          0                                          |
|                                                     |
|               QQ[][h, H   ..H   ]                   |
|                        2,1   2,2                    |
|     --------------------------------------[E ]      |
|     (- h - H   , - h*H    - H   , -h*H   )  0       |
|             2,1       2,1    2,2      2,2           |
|o6 : ------------------------------------------      |
|                           2                         |
|                 (H   E , E  + H   )                 |
|                   2,1 0   0    2,2                  |
+-----------------------------------------------------+

See also
========

  * blowup -- blow up an abstract variety along a subvariety

Ways to use exceptionalDivisor:
===============================

  * "exceptionalDivisor(AbstractVariety)"

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

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

extensionAlgebra -- extend a graded algebra by a graded module
**************************************************************

Synopsis
========

  * Usage:
        extensionAlgebra(f,c)
        extensionAlgebra(f,c,Codimension => r)
        extensionAlgebra(f,c,CoefficientRing => S)
        extensionAlgebra(f,c,Codimension => r, CoefficientRing => S)
  * Inputs:
      * f, from A to B
      * c, a homogeneous element of B
  * Optional inputs (Macaulay2Doc),:
      * Codimension => an integer (Macaulay2Doc), default value null,
        the desired degree of the inclusion map from B to E; only required if c
        = 0, and otherwise must match degree of c
      * CoefficientRing => a ring (Macaulay2Doc), default value
        null, a coefficient ring of A, which will be used as the coefficient
        ring of the output
  * Outputs:
      * a ring (Macaulay2Doc), the algebra obtained by making the
        direct sum of A and B[-r] into an algebra with the multiplication rule
        (a+b)(a'+b') = aa' + ab' + a'b + cbb'.
  * Consequences:
      * An algebra E is created and promotion methods from A and B to E and
        vice-versa are installed.  The natural pullback map from E to B given
        by sending a+b to f(a) + cb is stored in E.PullBack, see
        PullBack.

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

+-------------------------------+
|i1 : A = QQ[x]                 |
|                               |
|o1 = A                         |
|                               |
|o1 : PolynomialRing            |
+-------------------------------+
|i2 : B = QQ[y]                 |
|                               |
|o2 = B                         |
|                               |
|o2 : PolynomialRing            |
+-------------------------------+
|i3 : c = 2_B                   |
|                               |
|o3 = 2                         |
|                               |
|o3 : B                         |
+-------------------------------+
|i4 : f = map(B,A,gens B)       |
|                               |
|o4 = map (B, A, {y})           |
|                               |
|o4 : RingMap B <-- A           |
+-------------------------------+
|i5 : extensionAlgebra(f,c)     |
|                               |
|     QQ[E , x]                 |
|         0                     |
|o5 = ---------                 |
|       2                       |
|      E  - 2E                  |
|       0     0                 |
|                               |
|o5 : QuotientRing              |
+-------------------------------+
|i6 : oo.PullBack               |
|                               |
|             QQ[E , x]         |
|                 0             |
|o6 = map (B, ---------, {2, y})|
|               2               |
|              E  - 2E          |
|               0     0         |
|                               |
|                   QQ[E , x]   |
|                       0       |
|o6 : RingMap B <-- ---------   |
|                     2         |
|                    E  - 2E    |
|                     0     0   |
+-------------------------------+

Ways to use extensionAlgebra:
=============================

  * "extensionAlgebra(RingMap,RingElement)"

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

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

exteriorPower(AbstractSheaf) -- alternating sum of exterior powers
******************************************************************

Synopsis
========

  * Function: exteriorPower (Macaulay2Doc),
  * Usage:
        exteriorPower F
  * Inputs:
      * F, which should be effective
  * Optional inputs (Macaulay2Doc),:
      * Strategy (Macaulay2Doc),
        => ..., default value null,
  * Outputs:
      *

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

+-----------------------------------------------------------------+
|i1 : base(7, Bundle => (E,4,c))                                  |
|                                                                 |
|o1 = a variety                                                   |
|                                                                 |
|o1 : an abstract variety of dimension 7                          |
+-----------------------------------------------------------------+
|i2 : E                                                           |
|                                                                 |
|o2 = E                                                           |
|                                                                 |
|o2 : an abstract sheaf of rank 4 on a variety                    |
+-----------------------------------------------------------------+
|i3 : exteriorPower E                                             |
|                                                                 |
|o3 = a sheaf                                                     |
|                                                                 |
|o3 : an abstract sheaf of rank 0 on a variety                    |
+-----------------------------------------------------------------+
|i4 : chern oo                                                    |
|                                                                 |
|                              2                   3              |
|o4 = 1 - 6c  + 12c c  + (- 20c c  + 10c c ) + (30c c  - 30c c c )|
|           4      1 4         1 4      2 4        1 4      1 2 4 |
|                                                                 |
|o4 : QQ[c ..c ]                                                  |
|         1   4                                                   |
+-----------------------------------------------------------------+

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

  * exteriorPower(AbstractSheaf), --
    alternating sum of exterior powers

exteriorPower(ZZ,AbstractSheaf)
*******************************

Synopsis
========

  * Function: exteriorPower (Macaulay2Doc),
  * Usage:
        exteriorPower(n,F)
        exteriorPower_n F
  * Inputs:
      * n,
      * F,
  * Optional inputs (Macaulay2Doc),:
      * Strategy (Macaulay2Doc),
        => ..., default value null,
  * Outputs:
      * the $n$-th exterior power of $F$

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

+-----------------------------------------------------------------------------+
|i1 : tangentBundle abstractProjectiveSpace 4                                 |
|                                                                             |
|o1 = a sheaf                                                                 |
|                                                                             |
|o1 : an abstract sheaf of rank 4 on a flag bundle                            |
+-----------------------------------------------------------------------------+
|i2 : exteriorPower_4 oo                                                      |
|                                                                             |
|o2 = a sheaf                                                                 |
|                                                                             |
|o2 : an abstract sheaf of rank 1 on a flag bundle                            |
+-----------------------------------------------------------------------------+
|i3 : chern oo                                                                |
|                                                                             |
|o3 = 1 + 5H                                                                  |
|           2,1                                                               |
|                                                                             |
|                                QQ[][h, H   ..H   ]                          |
|                                         2,1   2,4                           |
|o3 : ------------------------------------------------------------------------|
|     (- h - H   , - h*H    - H   , - h*H    - H   , - h*H    - H   , -h*H   )|
|             2,1       2,1    2,2       2,2    2,3       2,3    2,4      2,4 |
+-----------------------------------------------------------------------------+

See also
========

  * symmetricPower(RingElement,AbstractSheaf)
    -- symmetric power of an
    abstract sheaf
  * schur(List,AbstractSheaf) -- apply
    a Schur functor to an abstract sheaf
  * determinant(AbstractSheaf), --
    determinant of an abstract sheaf

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

  * exteriorPower(ZZ,AbstractSheaf)

FlagBundle -- the class of all flag bundles
*******************************************

Functions and methods returning an abstract flag bundle:
========================================================

  * abstractProjectiveSpace -- make a
    projective space
  * abstractProjectiveSpace' -- make a
    projective space
  * flagBundle -- make a flag bundle
  * projectiveBundle -- make a projective bundle from
    an abstract sheaf
  * projectiveBundle' -- make a projective bundle
    from an abstract sheaf

Methods that use an abstract flag bundle:
=========================================

  * "bundles(FlagBundle)" -- see bundles, -- get the list of
    tautological line bundles on a flag bundle
  * "incidenceCorrespondence(FlagBundle,FlagBundle)" -- see
    incidenceCorrespondence, -- build containment
    correspondence between two Grassmannians
  * map(FlagBundle,AbstractVariety,AbstractSheaf)
    -- maps to
    projective bundles
  * "map(FlagBundle,AbstractVariety,List)" -- see
    map(FlagBundle,AbstractVarietyMap,List),
    -- make a map from an
    abstract variety to a flag bundle
  * map(FlagBundle,AbstractVarietyMap,List)
    -- make a map from an
    abstract variety to a flag bundle
  * map(FlagBundle,FlagBundle), --
    forgetful maps of flag varieties
  * "schubertCycle(List,FlagBundle)" -- see schubertCycle,
    -- compute Schubert Cycles on a Grassmannian, Fulton-style
  * "schubertCycle(Sequence,FlagBundle)" -- see schubertCycle,
    -- compute Schubert Cycles on a Grassmannian, Fulton-style
  * "FlagBundle _ List" -- see schubertCycle', -- compute
    Schubert Cycles on a Grassmannian, Grothendieck-style
  * "FlagBundle _ Sequence" -- see schubertCycle', --
    compute Schubert Cycles on a Grassmannian, Grothendieck-style
  * "schubertCycle'(List,FlagBundle)" -- see schubertCycle',
    -- compute Schubert Cycles on a Grassmannian,
    Grothendieck-style
  * "schubertCycle'(Sequence,FlagBundle)" -- see schubertCycle',
    -- compute Schubert Cycles on a Grassmannian,
    Grothendieck-style
  * "schubertRing(FlagBundle)" -- see schubertRing, -- get
    the Schubert ring of a Grassmannian
  * "tautologicalLineBundle(FlagBundle)" -- see tautologicalLineBundle,
    -- get the tautological line bundle of a flag
    bundle or abstract variety

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

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

flagBundle -- make a flag bundle
********************************

Synopsis
========

  * Usage:
        flagBundle(r,E)
  * Inputs:
      * r, a list (Macaulay2Doc), a list $\{r_0, ..., r_{n-1}\}$ of
        non-negative integers
      * E, an abstract sheaf, whose flag bundle is to be
        formed. If $E$ is, instead, an abstract variety,
        then a trivial sheaf on it is used. If $E$ is, instead, an
        integer (Macaulay2Doc), then a trivial sheaf on point,
        of rank $E$ is used. If $E$ is omitted, then a trivial sheaf on
        point, is used; its rank is the sum of the entries of $r$.
  * Optional inputs (Macaulay2Doc),:
      * VariableNames => a thing (Macaulay2Doc), default value
        null, used for specifying how the generators of the intersection ring
        of the resulting flag bundle are to be named. If no value is provided,
        then H_(i,j) = $H_{i,j}$ denotes the j-th Chern class of i-th
        tautological sheaf. If its value is a symbol, then that symbol is used
        instead of H. If its value is a list, then for each i, its i-th entry
        specifies how the Chern classes of the i-th tautological sheaf are to
        be named. If the i-th entry is omitted (i.e., is null (Macaulay2Doc)),
        then the default names are used. If the i-th
        entry is a symbol, say c, then the names are c_1 .. c_(r_i). If the
        i-th entry is a string, say c, then the names are c1, c2, c3, ... . If
        the i-th entry is a list, its entries are used as the names.
      * QuotientBundles => a Boolean value (Macaulay2Doc),
        default value true, whether the additional tautological subquotient
        bundle, needed to make up the discrepancy between the sum of the rank
        specified by $r$ and the rank of $E$, should be at the bottom of the
        filtration.
      * Isotropic => a Boolean value (Macaulay2Doc), default
        value false, whether to produce the isotropic flag bundle; in that
        case, the vector bundle should have even rank.
  * Outputs:
      * F, an abstract flag bundle, the flag bundle over the
        variety of $E$ parametrizing filtrations $0 = E_0 \subseteq{} E_1
        \subseteq{} ... \subseteq{} E_n = E$ of $E$ whose successive
        subquotients are vector bundles $E_{i+1}/E_i$ of rank $r_i$
  * Consequences:
      * The list r of ranks can be obtained later with F.BundleRanks, see
        BundleRanks. Its sum can be obtained with F.Rank.
      * The list of consecutive quotients in the tautological filtration can be
        obtained later with bundles F, see bundles. See also
        SubBundles, and QuotientBundles.
      * The (relative) tautological line bundle can be obtained later with
        OO_F(1).
      * The structure map from F to the variety of E can be obtained later with
        F.StructureMap, see StructureMap. Abstract sheaves
        and cycle classes can be pulled back and pushed forward, see
        AbstractVarietyMap ^*, and
        AbstractVarietyMap _*.  Integration will
        work if it works on the variety of E, see integral.
        The (relative) tangent bundle can be obtained from it, see
        tangentBundle(AbstractVarietyMap).

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

+-----------------------------------------------------------------------------+
|i1 : base(3,Bundle => (E,4,c))                                               |
|                                                                             |
|o1 = a variety                                                               |
|                                                                             |
|o1 : an abstract variety of dimension 3                                      |
+-----------------------------------------------------------------------------+
|i2 : F = flagBundle({2,2},E)                                                 |
|                                                                             |
|o2 = F                                                                       |
|                                                                             |
|o2 : a flag bundle with subquotient ranks {2:2}                              |
+-----------------------------------------------------------------------------+
|i3 : bundles F                                                               |
|                                                                             |
|o3 = (a sheaf, a sheaf)                                                      |
|                                                                             |
|o3 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i4 : rank \ oo                                                               |
|                                                                             |
|o4 = (2, 2)                                                                  |
|                                                                             |
|o4 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i5 : chern \ ooo                                                             |
|                                                                             |
|                            2                                                |
|o5 = (1 + (- H    + c ) + (H    - H    - c H    + c ), 1 + H    + H   )      |
|              2,1    1      2,1    2,2    1 2,1    2        2,1    2,2       |
|                                                                             |
|o5 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i6 : product toList oo                                                       |
|                                                                             |
|o6 = 1 + c  + c  + c                                                         |
|          1    2    3                                                        |
|                                                                             |
|                                       QQ[c ..c ][H   ..H   ]                |
|                                           1   3   1,1   2,2                 |
|o6 : ------------------------------------------------------------------------|
|     (- H    - H    + c , - H    - H   H    - H    + c , - H   H    - H   H  |
|         1,1    2,1    1     1,2    1,1 2,1    2,2    2     1,2 2,1    1,1 2,|
|-----------------------------------------------------------------------------|
|------------------                                                           |
|  + c , -H   H   )                                                           |
|2    3    1,2 2,2                                                            |
+-----------------------------------------------------------------------------+
|i7 : intersectionRing flagBundle({2,2},E,VariableNames=>{{a,b},t})           |
|                                                                             |
|                         QQ[c ..c ][a..b, t ..t ]                            |
|                             1   3         1   2                             |
|o7 = ----------------------------------------------------------------        |
|     (- a - t  + c , - b - a*t  - t  + c , - b*t  - a*t  + c , -b*t )        |
|             1    1           1    2    2       1      2    3      2         |
|                                                                             |
|o7 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+

See also
========

  * abstractProjectiveSpace -- make a
    projective space
  * projectiveBundle -- make a projective bundle from
    an abstract sheaf

Ways to use flagBundle:
=======================

  * "flagBundle(List)"
  * "flagBundle(List,AbstractSheaf)"
  * "flagBundle(List,AbstractVariety)"
  * "flagBundle(List,ZZ)"

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

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

Hom(AbstractSheaf,AbstractSheaf) -- Hom between abstract sheaves
****************************************************************

Synopsis
========

  * Function: Hom (Macaulay2Doc),
  * Usage:
        Hom(E,F)
  * Inputs:
      * E,
      * F,
  * Optional inputs (Macaulay2Doc),:
      * DegreeLimit (Macaulay2Doc), => ..., default value null,
      * MinimalGenerators (Macaulay2Doc), => ..., default value true,
      * Strategy (Macaulay2Doc), => ..., default value null,
  * Outputs:
      * the tensor product of $F$ with the dual of $E$

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

+-----------------------------------------------+
|i1 : X = abstractProjectiveSpace 1             |
|                                               |
|o1 = X                                         |
|                                               |
|o1 : a flag bundle with subquotient ranks {2:1}|
+-----------------------------------------------+
|i2 : Hom(OO_X(3),OO_X)                         |
|                                               |
|o2 = a sheaf                                   |
|                                               |
|o2 : an abstract sheaf of rank 1 on X          |
+-----------------------------------------------+
|i3 : chi oo                                    |
|                                               |
|o3 = -2                                        |
+-----------------------------------------------+

See also
========

  * dual (Macaulay2Doc) -- dual module or map

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

  * Hom(AbstractSheaf,AbstractSheaf)
    -- Hom between abstract sheaves

id _ AbstractVariety -- the identity map of an abstract variety
***************************************************************

Synopsis
========

  * Scripted functor: id (Macaulay2Doc),
  * Usage:
        id_X
  * Inputs:
      * X,
  * Outputs:
      * the identity map from X to itself

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

+------------------------------------------------+
|i1 : X = abstractProjectiveSpace 4              |
|                                                |
|o1 = X                                          |
|                                                |
|o1 : a flag bundle with subquotient ranks {1, 4}|
+------------------------------------------------+
|i2 : id_X                                       |
|                                                |
|o2 = a variety map                              |
|                                                |
|o2 : a map to X from X                          |
+------------------------------------------------+

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

  * id _ AbstractVariety -- the identity map of
    an abstract variety

IncidenceCorrespondence -- the class of all incidence correspondences
*********************************************************************

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

An incidence correspondence $I$ is a correspondence from an
AbstractVariety, $X$ (the source (Macaulay2Doc),
of $I$) to another AbstractVariety $Y$ (the target (Macaulay2Doc),
of $I$) which is mediated by a third AbstractVariety $Z$, together with
AbstractVarietyMap,s $f:Z\rightarrow X$ and $g:Z\rightarrow
Y$.

Given a cycle $x$ on $X$, the pushforward of $x$ along $I$ is $$I_* x = g_* f^*
x,$$ and similarly for bundles on $X$.  Likewise, if $y$ is a cycle on $Y$, the
pullback of $y$ along $I$ is $$I^* y = f_* g^* y,$$ and similarly for bundles
on $Y$.  See Correspondence ^*, and
Correspondence _*, for more info.

The tuple $(Z,f,g)$ can be accessed via the intermediates,
command.

Functions and methods returning an incidence correspondence:
============================================================

  * incidenceCorrespondence -- build
    containment correspondence between two Grassmannians
  * "transpose(IncidenceCorrespondence)" -- see
    transpose(Correspondence), -- reverse the
    direction of a correspondence

Methods that use an incidence correspondence:
=============================================

  * "intermediates(IncidenceCorrespondence)" -- see intermediates,

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

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

incidenceCorrespondence -- build containment correspondence between two Grassmannians
*************************************************************************************

Synopsis
========

  * Usage:
        incidenceCorrespondence(G2,G1)
  * Inputs:
      * G2, an abstract flag bundle, a Grassmannian of
        $b$-dimensional subbundles of a vector bundle $E$
      * G1, an abstract flag bundle, another Grassmannian of
        $a$-dimensional subbundles of the same bundle $E$
  * Outputs:
      * an incidence correspondence, from $G1$
        to $G2$, namely the correspondence whose intermediate term is
        flagBundle({a,b-a,n-b},E) (in the case that $a<=b$).  This intermediate
        term can be viewed as those pairs of subbundles $(V_1,V_2)$ of $E$ of
        ranks $a$ and $b$, respectively, such that $V_1 \subseteq V_2$.

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

+-----------------------------------------------------------------------------+
|i1 : P3 = flagBundle({1,3},VariableNames => H)                               |
|                                                                             |
|o1 = P3                                                                      |
|                                                                             |
|o1 : a flag bundle with subquotient ranks {1, 3}                             |
+-----------------------------------------------------------------------------+
|i2 : GG13 = flagBundle({2,2},VariableNames => K)                             |
|                                                                             |
|o2 = GG13                                                                    |
|                                                                             |
|o2 : a flag bundle with subquotient ranks {2:2}                              |
+-----------------------------------------------------------------------------+
|i3 : I = incidenceCorrespondence(GG13,P3)                                    |
|                                                                             |
|o3 = I                                                                       |
|                                                                             |
|o3 : an incidence correspondence from P3 to GG13                             |
+-----------------------------------------------------------------------------+
|i4 : c = chern(1, last bundles P3) --the hyperplane class                    |
|                                                                             |
|o4 = H                                                                       |
|      2,1                                                                    |
|                                                                             |
|                          QQ[][H   , H   ..H   ]                             |
|                                1,1   2,1   2,3                              |
|o4 : ----------------------------------------------------------------        |
|     (- H    - H   , - H   H    - H   , - H   H    - H   , -H   H   )        |
|         1,1    2,1     1,1 2,1    2,2     1,1 2,2    2,3    1,1 2,3         |
+-----------------------------------------------------------------------------+
|i5 : I_* (c^2) --the class in GG13 corresponding to lines meeting a given lin|
|                                                                             |
|o5 = K                                                                       |
|      2,1                                                                    |
|                                                                             |
|                                   QQ[][K   ..K   ]                          |
|                                         1,1   2,2                           |
|o5 : ------------------------------------------------------------------------|
|     (- K    - K   , - K    - K   K    - K   , - K   K    - K   K   , -K   K |
|         1,1    2,1     1,2    1,1 2,1    2,2     1,2 2,1    1,1 2,2    1,2 2|
|-----------------------------------------------------------------------------|
|e, i.e. sigma_1                                                              |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|---                                                                          |
|  )                                                                          |
|,2                                                                           |
+-----------------------------------------------------------------------------+
|i6 : d = (chern(2, last bundles GG13))^2 --the class of a point in GG13      |
|                                                                             |
|      2                                                                      |
|o6 = K                                                                       |
|      2,2                                                                    |
|                                                                             |
|                                   QQ[][K   ..K   ]                          |
|                                         1,1   2,2                           |
|o6 : ------------------------------------------------------------------------|
|     (- K    - K   , - K    - K   K    - K   , - K   K    - K   K   , -K   K |
|         1,1    2,1     1,2    1,1 2,1    2,2     1,2 2,1    1,1 2,2    1,2 2|
|-----------------------------------------------------------------------------|
|---                                                                          |
|  )                                                                          |
|,2                                                                           |
+-----------------------------------------------------------------------------+
|i7 : I^* d --the class in $P3$ of points lying in the line corresponding to  |
|                                                                             |
|o7 = H                                                                       |
|      2,2                                                                    |
|                                                                             |
|                          QQ[][H   , H   ..H   ]                             |
|                                1,1   2,1   2,3                              |
|o7 : ----------------------------------------------------------------        |
|     (- H    - H   , - H   H    - H   , - H   H    - H   , -H   H   )        |
|         1,1    2,1     1,1 2,1    2,2     1,1 2,2    2,3    1,1 2,3         |
|-----------------------------------------------------------------------------|
|d, i.e. c^2                                                                  |
+-----------------------------------------------------------------------------+

Ways to use incidenceCorrespondence:
====================================

  * "incidenceCorrespondence(FlagBundle,FlagBundle)"
  * incidenceCorrespondence(List), --
    build containment correspondence between two Grassmannians
  * incidenceCorrespondence(List,AbstractSheaf)
    -- build containment
    correspondence between two Grassmannians

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

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

incidenceCorrespondence(List) -- build containment correspondence between two Grassmannians
*******************************************************************************************

Synopsis
========

  * Function: incidenceCorrespondence,
  * Usage:
        incidenceCorrespondence L
  * Inputs:
      * L, a list (Macaulay2Doc), of three integers, $L={a,b,n}$,
        such that $0 \leq a \leq n$ and $0\leq b \leq n$.
  * Outputs:
      * an incidence correspondence, from $G1 =
        G(a,n)$ to $G2 = G(b,n)$, same as incidenceCorrespondence(G1,G2)

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

+--------------------------------------------------------------------+
|i1 : I = incidenceCorrespondence({1,2,3})                           |
|                                                                    |
|o1 = I                                                              |
|                                                                    |
|o1 : an incidence correspondence from a flag bundle to a flag bundle|
+--------------------------------------------------------------------+
|i2 : source I                                                       |
|                                                                    |
|o2 = a flag bundle                                                  |
|                                                                    |
|o2 : a flag bundle with subquotient ranks {1..2}                    |
+--------------------------------------------------------------------+
|i3 : target I                                                       |
|                                                                    |
|o3 = a flag bundle                                                  |
|                                                                    |
|o3 : a flag bundle with subquotient ranks {2, 1}                    |
+--------------------------------------------------------------------+

See also
========

  * incidenceCorrespondence(FlagBundle,FlagBundle)
    -- build containment correspondence between two
    Grassmannians
  * incidenceCorrespondence(List,AbstractSheaf)
    -- build containment
    correspondence between two Grassmannians

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

  * incidenceCorrespondence(List), --
    build containment correspondence between two Grassmannians

incidenceCorrespondence(List,AbstractSheaf) -- build containment correspondence between two Grassmannians
*********************************************************************************************************

Synopsis
========

  * Function: incidenceCorrespondence,
  * Usage:
        incidenceCorrespondence(L,E)
  * Inputs:
      * L, a list (Macaulay2Doc), of two integers, $L={a,b}$, such
        that $0 \leq a$ and $0\leq b$.
      * E, an abstract sheaf, a vector bundle of rank
        $n$, such that $a\leq n$ and $b\leq n$.
  * Outputs:
      * an incidence correspondence, from $G1 =
        G(a,E)$ to $G2 = G(b,E)$, same as incidenceCorrespondence(G1,G2)

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

+--------------------------------------------------------------------+
|i1 : B = flagBundle({3,1})                                          |
|                                                                    |
|o1 = B                                                              |
|                                                                    |
|o1 : a flag bundle with subquotient ranks {3, 1}                    |
+--------------------------------------------------------------------+
|i2 : E = first bundles B                                            |
|                                                                    |
|o2 = E                                                              |
|                                                                    |
|o2 : an abstract sheaf of rank 3 on B                               |
+--------------------------------------------------------------------+
|i3 : incidenceCorrespondence({1,2},E)                               |
|                                                                    |
|o3 = an incidence correspondence                                    |
|                                                                    |
|o3 : an incidence correspondence from a flag bundle to a flag bundle|
+--------------------------------------------------------------------+

See also
========

  * incidenceCorrespondence(FlagBundle,FlagBundle)
    -- build containment correspondence between two
    Grassmannians
  * incidenceCorrespondence(List), --
    build containment correspondence between two Grassmannians

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

  * incidenceCorrespondence(List,AbstractSheaf)
    -- build containment
    correspondence between two Grassmannians

inclusion -- build the freest possible inclusion map
****************************************************

Synopsis
========

  * Usage:
        inclusion(f, NormalClass => c, Codimension => r, SuperTangent => tY, SuperDimension => dY, Base => S)
        inclusion(f, SubTangent => tX, SubDimension => dX, SuperTangent => tY, SuperDimension => dY)
        inclusion(f)
  * Inputs:
      * f, from A to B; we think of A as part of the Chow ring of Y and B as
        part of the Chow ring of X
  * Optional inputs (Macaulay2Doc),:
      * Codimension => an integer (Macaulay2Doc), default value null,
        the codimension of X in Y
      * SubDimension => an integer (Macaulay2Doc), default value
        null, the dimension of X
      * SuperDimension => an integer (Macaulay2Doc), default value
        null, the dimension of Y
      * SubTangent => a ring element (Macaulay2Doc), default
        value null, element of B, the Chern class of the tangent bundle of X
      * SuperTangent => a ring element (Macaulay2Doc),
        default value null, element of A, the Chern class of the tangent bundle
        of Y
      * NormalClass => a ring element (Macaulay2Doc),
        default value null, element of B, the Chern class of the normal bundle
        of X in Y
      * Base => a thing (Macaulay2Doc), default value null, a Ring
        or AbstractVariety, the base ring/variety to work over
  * Outputs:
      * an abstract variety map, the natural map
        from X to Z.
  * Consequences:
      * An extensionAlgebra, of A by B is built, with
        normal class equal to the degree-r part of c.  This algebra is made
        into the ring of a variety Z, see abstractVariety.
        A tangent class is installed on Z,
        see tangentBundle.  If A and B each have an
        integral, defined, then an integral is defined on the
        coordinate ring of Z, and a StructureMap, is
        installed on Z.
      * A variety X for B is built if B is not already the ring of a variety,
        see abstractVariety.  A tangent
        class is installed on X if it does not already have one, see
        tangentBundle.  A StructureMap, is
        installed if B already has an integral, defined.
      * If Base option is used, the supplied ring is made into the ring of a
        variety, if it is not already one.

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

Given the pullback map f from A to B, builds the freest possible extension E of
A by B (see extensionAlgebra), and then adds
appropriate metadata to make the maps from E to B and vice-versa into an
AbstractVarietyMap.  Enough information must be given to
compute the dimensions of X and Y, either by using the SubDimension,
SuperDimension, and Codimension options, or by having varieties already
attached to A and/or B.  Likewise, enough information must be given to compute
the tangent classes of X and Y.

This construction is useful for computations where the pullback map is known
but the pushforward is either not known or cannot be defined.

+-----------------------------------------------------------------------------+
|i1 : p = point                                                               |
|                                                                             |
|o1 = point                                                                   |
|                                                                             |
|o1 : an abstract variety of dimension 0                                      |
+-----------------------------------------------------------------------------+
|i2 : S = intersectionRing p                                                  |
|                                                                             |
|o2 = S                                                                       |
|                                                                             |
|o2 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i3 : Y = projectiveBundle(5,p)                                               |
|                                                                             |
|o3 = Y                                                                       |
|                                                                             |
|o3 : a flag bundle with subquotient ranks {1, 5}                             |
+-----------------------------------------------------------------------------+
|i4 : A = intersectionRing Y                                                  |
|                                                                             |
|o4 = A                                                                       |
|                                                                             |
|o4 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i5 : B = S[h, Join => false]/h^3 -- A^*(P2), but using 2 times a line as the |
|                                                                             |
|o5 = B                                                                       |
|                                                                             |
|o5 : QuotientRing                                                            |
|-----------------------------------------------------------------------------|
|generating class:                                                            |
+-----------------------------------------------------------------------------+
|i6 : integral B := (b) -> (4 * coefficient((B_0)^2, b))                      |
|                                                                             |
|o6 = FunctionClosure[stdio:6:14-6:50]                                        |
|                                                                             |
|o6 : FunctionClosure                                                         |
+-----------------------------------------------------------------------------+
|i7 : c = 1 + (9/2)*h + (15/2)*h^2 -- normal class                            |
|                                                                             |
|     15 2   9                                                                |
|o7 = --h  + -h + 1                                                           |
|      2     2                                                                |
|                                                                             |
|o7 : B                                                                       |
+-----------------------------------------------------------------------------+
|i8 : f = map(B,A,{-h, h, h^2, h^3, h^4, h^5})                                |
|                                                                             |
|                         2                                                   |
|o8 = map (B, A, {-h, h, h , 0, 0, 0})                                        |
|                                                                             |
|o8 : RingMap B <-- A                                                         |
+-----------------------------------------------------------------------------+
|i9 : i = inclusion(f,                                                        |
|         NormalClass => c,                                                   |
|         Codimension => 3,                                                   |
|         Base => p) -- Base not necessary, will be correctly computed        |
|                                                                             |
|o9 = i                                                                       |
|                                                                             |
|o9 : a map to a variety from a variety                                       |
+-----------------------------------------------------------------------------+
|i10 : Z = target i                                                           |
|                                                                             |
|o10 = Z                                                                      |
|                                                                             |
|o10 : an abstract variety of dimension 5                                     |
+-----------------------------------------------------------------------------+
|i11 : X = source i                                                           |
|                                                                             |
|o11 = X                                                                      |
|                                                                             |
|o11 : an abstract variety of dimension 2                                     |
+-----------------------------------------------------------------------------+
|i12 : Xstruct = X / point                                                    |
|                                                                             |
|o12 = Xstruct                                                                |
|                                                                             |
|o12 : a map to point from X                                                  |
+-----------------------------------------------------------------------------+
|i13 : rank Xstruct_* tangentBundle X                                         |
|                                                                             |
|o13 = 8                                                                      |
+-----------------------------------------------------------------------------+
|i14 : integral chern tangentBundle Z                                         |
|                                                                             |
|o14 = 6                                                                      |
|                                                                             |
|o14 : S                                                                      |
+-----------------------------------------------------------------------------+

Ways to use inclusion:
======================

  * "inclusion(RingMap)"

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

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

integral -- compute an integral (push forward a cycle to the base)
******************************************************************

Synopsis
========

  * Usage:
        integral f
  * Inputs:
      * f, a ring element (Macaulay2Doc), a cycle class in
        the intersection ring of an abstract variety
  * Outputs:
      * a ring element (Macaulay2Doc), the integral of $f$.

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

In this example we compute the number of lines meeting four lines in space.

+-----------------------------------------------+
|i1 : G = flagBundle {2,2}                      |
|                                               |
|o1 = G                                         |
|                                               |
|o1 : a flag bundle with subquotient ranks {2:2}|
+-----------------------------------------------+
|i2 : dim G                                     |
|                                               |
|o2 = 4                                         |
+-----------------------------------------------+
|i3 : A = intersectionRing G                    |
|                                               |
|o3 = A                                         |
|                                               |
|o3 : QuotientRing                              |
+-----------------------------------------------+
|i4 : f = (chern_1 OO_G(1))^4                   |
|                                               |
|       2                                       |
|o4 = 2H                                        |
|       2,2                                     |
|                                               |
|o4 : A                                         |
+-----------------------------------------------+
|i5 : integral f                                |
|                                               |
|o5 = 2                                         |
+-----------------------------------------------+

Normally this integral will be an element of the intersection ring of
point, and thus will essentially be a rational number, but it could be
in any base variety, and would be obtained by pushing forward along the
structure maps of flag bundles until the (ultimate) base variety is reached.

+-----------------------------------------------+
|i6 : pt = base n                               |
|                                               |
|o6 = pt                                        |
|                                               |
|o6 : an abstract variety of dimension 0        |
+-----------------------------------------------+
|i7 : F = flagBundle_{2,2} pt                   |
|                                               |
|o7 = F                                         |
|                                               |
|o7 : a flag bundle with subquotient ranks {2:2}|
+-----------------------------------------------+
|i8 : integral (chern_1 OO_F(n))^4              |
|                                               |
|       4                                       |
|o8 = 2n                                        |
|                                               |
|o8 : QQ[n]                                     |
+-----------------------------------------------+

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

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

intermediates
*************

Synopsis
========

  * Usage:
        intermediates I
  * Inputs:
      * I, an incidence correspondence,
  * Outputs:
      * a triple $(Z,f,g)$ where $Z$ is the AbstractVariety mediating the
        Correspondence, $f$ is the AbstractVarietyMap from $Z$ to the source of
        $I$, and $g$ is the AbstractVarietyMap from $Z$ to the target of $I$.

Ways to use intermediates:
==========================

  * "intermediates(IncidenceCorrespondence)"

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

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

IntersectionRing -- a key used for storing the intersection ring in an abstract variety
***************************************************************************************

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

This symbol is used as a key internally.

See also
========

  * intersectionRing -- get the
    intersection ring of an abstract variety

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

The object IntersectionRing, is a symbol (Macaulay2Doc).

intersectionRing(AbstractVariety) -- get the intersection ring of an abstract variety
*************************************************************************************

Synopsis
========

  * Function: intersectionRing,
  * Usage:
        intersectionRing X
  * Inputs:
      * X,
  * Outputs:
      * the intersection ring of $X$

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

+---------------------------------------------------------+
|i1 : intersectionRing abstractProjectiveSpace' 3         |
|                                                         |
|                      QQ[][H   ..H   , h]                |
|                            1,1   1,3                    |
|o1 = ----------------------------------------------------|
|     (- H    - h, - H    - H   h, - H    - H   h, -H   h)|
|         1,1         1,2    1,1      1,3    1,2     1,3  |
|                                                         |
|o1 : QuotientRing                                        |
+---------------------------------------------------------+

The variables may not have been assigned their values in the intersection ring
yet:

+---------------------------------------------------------+
|i2 : H_(1,1)                                             |
|                                                         |
|o2 = -h                                                  |
|                                                         |
|                      QQ[][H   ..H   , h]                |
|                            1,1   1,3                    |
|o2 : ----------------------------------------------------|
|     (- H    - h, - H    - H   h, - H    - H   h, -H   h)|
|         1,1         1,2    1,1      1,3    1,2     1,3  |
+---------------------------------------------------------+

The function use (Macaulay2Doc), will arrange for the assignment of
values:

+---------------------------------------------------------+
|i3 : use ooo                                             |
|                                                         |
|                      QQ[][H   ..H   , h]                |
|                            1,1   1,3                    |
|o3 = ----------------------------------------------------|
|     (- H    - h, - H    - H   h, - H    - H   h, -H   h)|
|         1,1         1,2    1,1      1,3    1,2     1,3  |
|                                                         |
|o3 : QuotientRing                                        |
+---------------------------------------------------------+
|i4 : H_(1,1), H_(1,2), H_(1,3)                           |
|                                                         |
|           2    3                                        |
|o4 = (-h, h , -h )                                       |
|                                                         |
|o4 : Sequence                                            |
+---------------------------------------------------------+

See also
========

  * abstractProjectiveSpace' -- make a
    projective space
  * IntersectionRing -- a key used for storing the
    intersection ring in an abstract variety

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

  * intersectionRing(AbstractVariety)
    -- get the intersection ring of an
    abstract variety

Isotropic -- make an isotropic flag bundle
******************************************

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

Isotropic is the name for an optional argument that directs the construction of
an isotropic flag bundle.

Functions with optional argument named Isotropic:
=================================================

  * "flagBundle(...,Isotropic=>...)" -- see flagBundle, --
    make a flag bundle

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

The object Isotropic, is a symbol (Macaulay2Doc).

kernelBundle(ZZ,AbstractSheaf,AbstractSheaf)
********************************************

Synopsis
========

  * Function: kernelBundle,
  * Usage:
        kernelBundle(k,B,A)
  * Inputs:
      * k,
      * B,
      * A,
  * Outputs:
      * the kernel bundle on the locus where the rank of a generic map from A
        to B is at most k, assuming that the rank doesn't drop further

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

+-----------------------------------------------------------------------------+
|i1 : X = base(5, Bundle => (A,3,a), Bundle => (B,3,b))                       |
|                                                                             |
|o1 = X                                                                       |
|                                                                             |
|o1 : an abstract variety of dimension 5                                      |
+-----------------------------------------------------------------------------+
|i2 : E = kernelBundle(2,B,A)                                                 |
|                                                                             |
|o2 = E                                                                       |
|                                                                             |
|o2 : an abstract sheaf of rank 1 on a variety                                |
+-----------------------------------------------------------------------------+
|i3 : Z = variety E                                                           |
|                                                                             |
|o3 = Z                                                                       |
|                                                                             |
|o3 : an abstract variety of dimension 4                                      |
+-----------------------------------------------------------------------------+
|i4 : i = Z/X                                                                 |
|                                                                             |
|o4 = i                                                                       |
|                                                                             |
|o4 : a map to X from Z                                                       |
+-----------------------------------------------------------------------------+
|i5 : i_* 1                                                                   |
|                                                                             |
|o5 = - a  + b                                                                |
|        1    1                                                               |
|                                                                             |
|o5 : QQ[a ..b ]                                                              |
|         1   3                                                               |
+-----------------------------------------------------------------------------+
|i6 : i_* chern_1 E                                                           |
|                                                                             |
|        2                                                                    |
|o6 = - a  + a  + a b  - b                                                    |
|        1    2    1 1    2                                                   |
|                                                                             |
|o6 : QQ[a ..b ]                                                              |
|         1   3                                                               |
+-----------------------------------------------------------------------------+
|i7 : i_* (chern_1 E)^2                                                       |
|                                                                             |
|        3                 2                                                  |
|o7 = - a  + 2a a  - a  + a b  - a b  - a b  + b                              |
|        1     1 2    3    1 1    2 1    1 2    3                             |
|                                                                             |
|o7 : QQ[a ..b ]                                                              |
|         1   3                                                               |
+-----------------------------------------------------------------------------+
|i8 : i_* (chern_1 E)^3                                                       |
|                                                                             |
|        4     2      2            3                       2                  |
|o8 = - a  + 3a a  - a  - 2a a  + a b  - 2a a b  + a b  - a b  + a b  + a b   |
|        1     1 2    2     1 3    1 1     1 2 1    3 1    1 2    2 2    1 3  |
|                                                                             |
|o8 : QQ[a ..b ]                                                              |
|         1   3                                                               |
+-----------------------------------------------------------------------------+
|i9 : i_* E                                                                   |
|                                                                             |
|o9 = a sheaf                                                                 |
|                                                                             |
|o9 : an abstract sheaf of rank 0 on X                                        |
+-----------------------------------------------------------------------------+
|i10 : integral (chern_1 E)^4                                                 |
|                                                                             |
|                  5     3         2     2              4       2        2    |
|o10 = integral(- a  + 4a a  - 3a a  - 3a a  + 2a a  + a b  - 3a a b  + a b  +|
|                  1     1 2     1 2     1 3     2 3    1 1     1 2 1    2 1  |
|                                                                             |
|o10 : Expression of class Adjacent                                           |
|-----------------------------------------------------------------------------|
|           3                       2                                         |
|2a a b  - a b  + 2a a b  - a b  + a b  - a b )                               |
|  1 3 1    1 2     1 2 2    3 2    1 3    2 3                                |
+-----------------------------------------------------------------------------+
|i11 : integral ch E                                                          |
|                                                                             |
|                  1 5   1 3     1   2   1 2      1        1 4     1 2        |
|o11 = integral(- --a  + -a a  - -a a  - -a a  + --a a  + --a b  - -a a b  +  |
|                 24 1   6 1 2   8 1 2   8 1 3   12 2 3   24 1 1   8 1 2 1    |
|                                                                             |
|o11 : Expression of class Adjacent                                           |
|-----------------------------------------------------------------------------|
| 1 2      1          1 3      1          1        1 2      1                 |
|--a b  + --a a b  - --a b  + --a a b  - --a b  + --a b  - --a b )            |
|24 2 1   12 1 3 1   24 1 2   12 1 2 2   24 3 2   24 1 3   24 2 3             |
+-----------------------------------------------------------------------------+
|i12 : F = kernelBundle(1,B,A)                                                |
|                                                                             |
|o12 = F                                                                      |
|                                                                             |
|o12 : an abstract sheaf of rank 2 on a variety                               |
+-----------------------------------------------------------------------------+
|i13 : W = variety F                                                          |
|                                                                             |
|o13 = W                                                                      |
|                                                                             |
|o13 : an abstract variety of dimension 1                                     |
+-----------------------------------------------------------------------------+
|i14 : j = W/X                                                                |
|                                                                             |
|o14 = j                                                                      |
|                                                                             |
|o14 : a map to X from W                                                      |
+-----------------------------------------------------------------------------+
|i15 : j_* chern_1 F                                                          |
|                                                                             |
|         2    2             2                      2      2    3             |
|o15 = a a  - a a  - a a  - a a b  + 2a a b  + a a b  - a b  + a b  - 2a a b  |
|       1 2    1 3    2 3    1 2 1     1 3 1    1 2 1    3 1    1 2     1 2 2 |
|      -----------------------------------------------------------------------|
|                2          2                                                 |
|      + a b  - a b b  + a b  + a b  - b b                                    |
|         3 2    1 1 2    1 2    2 3    2 3                                   |
|                                                                             |
|o15 : QQ[a ..b ]                                                             |
|          1   3                                                              |
+-----------------------------------------------------------------------------+

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

  * kernelBundle(ZZ,AbstractSheaf,AbstractSheaf)

map(FlagBundle,AbstractVariety,AbstractSheaf) -- maps to projective bundles
***************************************************************************

Synopsis
========

  * Function: map (Macaulay2Doc),
  * Usage:
        map(P,X,L)
  * Inputs:
      * P, an abstract flag bundle, the projectivization of
        some vector bundle E
      * X, an abstract variety,
      * L, an abstract sheaf, a line bundle on X, the
        desired pullback of $O_P(1)$.
  * Optional inputs (Macaulay2Doc),:
      * Degree (Macaulay2Doc), => ..., default value null,
      * DegreeLift (Macaulay2Doc), => ...,
        default value null,
      * DegreeMap (Macaulay2Doc), => ...,
        default value null,
  * Outputs:
      * an abstract variety map, the map from X to P
        such that the pullback of $O_P(1)$ is $L$

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

Accepts both Grothendieck-style and Fulton-style ${\mathbb P}(E)$, but in the
case a decision cannot be made based on ranks (i.e. when $E$ has rank $2$),
defaults to Fulton-style notation (so ${\mathbb P}(E)$ is the space of
sub-line-bundles of $E$).

Does not check whether $L$ is basepoint-free.  Weird results are probably
possible if $L$ is not.

+-----------------------------------------------------------------------------+
|i1 : X = flagBundle({2,2}) --the Grassmannian GG(1,3)                        |
|                                                                             |
|o1 = X                                                                       |
|                                                                             |
|o1 : a flag bundle with subquotient ranks {2:2}                              |
+-----------------------------------------------------------------------------+
|i2 : (S,Q) = bundles X                                                       |
|                                                                             |
|o2 = (S, Q)                                                                  |
|                                                                             |
|o2 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i3 : L = exteriorPower(2,dual S)                                             |
|                                                                             |
|o3 = L                                                                       |
|                                                                             |
|o3 : an abstract sheaf of rank 1 on X                                        |
+-----------------------------------------------------------------------------+
|i4 : P = flagBundle({5,1}) --Grothendieck-style PP^5                         |
|                                                                             |
|o4 = P                                                                       |
|                                                                             |
|o4 : a flag bundle with subquotient ranks {5, 1}                             |
+-----------------------------------------------------------------------------+
|i5 : f = map(P,X,L) -- Plücker embedding of GG(1,3) in PP^5                  |
|                                                                             |
|o5 = f                                                                       |
|                                                                             |
|o5 : a map to P from X                                                       |
+-----------------------------------------------------------------------------+
|i6 : H = last bundles P                                                      |
|                                                                             |
|o6 = H                                                                       |
|                                                                             |
|o6 : an abstract sheaf of rank 1 on P                                        |
+-----------------------------------------------------------------------------+
|i7 : f^* (chern(1,H)) -- hyperplane section, should be sigma_1               |
|                                                                             |
|o7 = H                                                                       |
|      2,1                                                                    |
|                                                                             |
|                                   QQ[][H   ..H   ]                          |
|                                         1,1   2,2                           |
|o7 : ------------------------------------------------------------------------|
|     (- H    - H   , - H    - H   H    - H   , - H   H    - H   H   , -H   H |
|         1,1    2,1     1,2    1,1 2,1    2,2     1,2 2,1    1,1 2,2    1,2 2|
|-----------------------------------------------------------------------------|
|---                                                                          |
|  )                                                                          |
|,2                                                                           |
+-----------------------------------------------------------------------------+
|i8 : f_* chern(0,S) --expect 2 times hyperplane class since GG(1,3) has degre|
|                                                                             |
|o8 = 2H                                                                      |
|       2,1                                                                   |
|                                                                             |
|                                             QQ[][H   ..H   , H   ]          |
|                                                   1,1   1,5   2,1           |
|o8 : ------------------------------------------------------------------------|
|     (- H    - H   , - H    - H   H   , - H    - H   H   , - H    - H   H   ,|
|         1,1    2,1     1,2    1,1 2,1     1,3    1,2 2,1     1,4    1,3 2,1 |
|-----------------------------------------------------------------------------|
|e 2                                                                          |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|------------------------------                                               |
| - H    - H   H   , -H   H   )                                               |
|    1,5    1,4 2,1    1,5 2,1                                                |
+-----------------------------------------------------------------------------+

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

  * map(FlagBundle,AbstractVariety,AbstractSheaf)
    -- maps to
    projective bundles

map(FlagBundle,AbstractVarietyMap,List) -- make a map from an abstract variety to a flag bundle
***********************************************************************************************

Synopsis
========

  * Function: map (Macaulay2Doc),
  * Usage:
        map(F,f,b)
        map(F,X,b)
  * Inputs:
      * F, over a variety S, of the form $flagBundle(\{r_0, ..., r_{n-1}\},E)$,
        say, where $E$ is an abstract sheaf on $S$
      * f, an abstract variety map, from a variety
        $X$, say, to $S$; or X, an abstract variety,
        with a structure map $f : X \rightarrow{} S$
      * b, of the form $\{B_0,...B_{n-1}\}$ whose elements are abstract sheaves
        on X, with $rank B_i = r_i$, for each i. The sheaves should be
        effective in the sense that $c_j B_i = 0$ for $j > r_i$. The sum of the
        sheaves should equal $f^* E$; alternatively, one of them can be omitted
        and it will be deduced from the condition on the sum.
  * Optional inputs (Macaulay2Doc),:
      * Degree (Macaulay2Doc), => ..., default value null, the
        value of this option is ignored
      * DegreeLift (Macaulay2Doc), => ...,
        default value null, the value of this option is ignored
      * DegreeMap (Macaulay2Doc), => ...,
        default value null, the value of this option is ignored
  * Outputs:
      * an abstract variety map, the map of abstract
        varieties $g : X \rightarrow{} F$ over $S$ such that $g^* (E_{i+1}/E_i)
        = B_i$, for each i, where $0 = E_0 \subseteq{} E_1 \subseteq{} ...
        \subseteq{} E_n = p^* E$ is the tautological filtration on $F$, and
        where $p : F \rightarrow{} S$ is the structure map of $F$.

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

Not implemented yet.

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

  * "map(FlagBundle,AbstractVariety,List)"
  * map(FlagBundle,AbstractVarietyMap,List)
    -- make a map from an
    abstract variety to a flag bundle

map(FlagBundle,FlagBundle) -- forgetful maps of flag varieties
**************************************************************

Synopsis
========

  * Function: map (Macaulay2Doc),
  * Usage:
        map(X,Y)
  * Inputs:
      * X, an abstract flag bundle, with ranks
        ${a_1,..,a_n}$ of some bundle $E$
      * Y, an abstract flag bundle, with ranks
        ${b_1,..,b_k}$ of the same bundle $E$, and such that there are indices
        $0 = i_0 < i_1 < \ldots < i_n = k$ such that for all $l$ from $1$ to
        $n$ we have $b_(i_(l-1)+1) + \ldots + b_(i_l) = a_l$.
  * Optional inputs (Macaulay2Doc),:
      * Degree (Macaulay2Doc), => ..., default value null,
      * DegreeLift (Macaulay2Doc), => ...,
        default value null,
      * DegreeMap (Macaulay2Doc), => ...,
        default value null,
  * Outputs:
      * an abstract variety map, the forgetful map
        from $Y$ to $X$

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

+---------------------------------------------------------+
|i1 : F1 = flagBundle({1,2,2,1,3})                        |
|                                                         |
|o1 = F1                                                  |
|                                                         |
|o1 : a flag bundle with subquotient ranks {1..2, 2, 1, 3}|
+---------------------------------------------------------+
|i2 : F2 = flagBundle({3,3,3})                            |
|                                                         |
|o2 = F2                                                  |
|                                                         |
|o2 : a flag bundle with subquotient ranks {3:3}          |
+---------------------------------------------------------+
|i3 : f = map(F2,F1)                                      |
|                                                         |
|o3 = f                                                   |
|                                                         |
|o3 : a map to F2 from F1                                 |
+---------------------------------------------------------+

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

  * map(FlagBundle,FlagBundle), --
    forgetful maps of flag varieties

OO _ AbstractVariety -- the structure sheaf of an abstract variety
******************************************************************

Synopsis
========

  * Operator: _ (Macaulay2Doc),
  * Usage:
        OO_X
  * Inputs:
      * X, an abstract variety,
  * Outputs:
      * the structure sheaf of X

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

+------------------------------------------------+
|i1 : X = abstractProjectiveSpace 4              |
|                                                |
|o1 = X                                          |
|                                                |
|o1 : a flag bundle with subquotient ranks {1, 4}|
+------------------------------------------------+
|i2 : OO_X                                       |
|                                                |
|o2 = a sheaf                                    |
|                                                |
|o2 : an abstract sheaf of rank 1 on X           |
+------------------------------------------------+
|i3 : rank oo                                    |
|                                                |
|o3 = 1                                          |
+------------------------------------------------+
|i4 : chi ooo                                    |
|                                                |
|o4 = 1                                          |
+------------------------------------------------+

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

  * OO _ AbstractVariety -- the structure sheaf
    of an abstract variety

point -- the default base variety of dimension 0
************************************************

Synopsis
========

  * Usage:
        point
  * Outputs:
      * an abstract variety, the default base variety
        of dimension 0, with intersection ring isomorphic to QQ (Macaulay2Doc),

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

+------------------------------------------------+
|i1 : point                                      |
|                                                |
|o1 = point                                      |
|                                                |
|o1 : an abstract variety of dimension 0         |
+------------------------------------------------+
|i2 : dim point                                  |
|                                                |
|o2 = 0                                          |
+------------------------------------------------+
|i3 : intersectionRing point                     |
|                                                |
|o3 = QQ[]                                       |
|                                                |
|o3 : PolynomialRing                             |
+------------------------------------------------+
|i4 : X = abstractProjectiveSpace 4              |
|                                                |
|o4 = X                                          |
|                                                |
|o4 : a flag bundle with subquotient ranks {1, 4}|
+------------------------------------------------+
|i5 : f = X.StructureMap                         |
|                                                |
|o5 = f                                          |
|                                                |
|o5 : a map to point from X                      |
+------------------------------------------------+
|i6 : target f                                   |
|                                                |
|o6 = point                                      |
|                                                |
|o6 : an abstract variety of dimension 0         |
+------------------------------------------------+

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

The object point, is an abstract variety.

projectiveBundle -- make a projective bundle from an abstract sheaf
*******************************************************************

Synopsis
========

  * Usage:
        projectiveBundle F
        projectiveBundle(n,X)
        projectiveBundle n
  * Inputs:
      * F, an abstract sheaf,
      * n, an integer (Macaulay2Doc),
      * X, an abstract variety,
  * Optional inputs (Macaulay2Doc),:
      * VariableNames => a thing (Macaulay2Doc), default value
        null, see flagBundle(...,VariableNames=>...),
  * Outputs:
      * the projective bundle of rank 1 sub-bundles of the abstract sheaf $F$.
        If $F$ is omitted, then a projective space of dimension $n$ over $X$ is
        produced. If $X$ is omitted, then point, is used as the
        base.

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

+------------------------------------------------+
|i1 : X = projectiveBundle 4                     |
|                                                |
|o1 = X                                          |
|                                                |
|o1 : a flag bundle with subquotient ranks {1, 4}|
+------------------------------------------------+
|i2 : F = OO_X(2) ++ OO_X(3) ++ OO_X(4)          |
|                                                |
|o2 = F                                          |
|                                                |
|o2 : an abstract sheaf of rank 3 on X           |
+------------------------------------------------+
|i3 : Y = projectiveBundle F                     |
|                                                |
|o3 = Y                                          |
|                                                |
|o3 : a flag bundle with subquotient ranks {1..2}|
+------------------------------------------------+
|i4 : dim Y                                      |
|                                                |
|o4 = 6                                          |
+------------------------------------------------+
|i5 : integral (chern_1 OO_Y(1))^(dim Y)         |
|                                                |
|o5 = 19981                                      |
+------------------------------------------------+
|i6 : bundles X/rank                             |
|                                                |
|o6 = (1, 4)                                     |
|                                                |
|o6 : Sequence                                   |
+------------------------------------------------+

Caveat
======

Perhaps this should be merged with abstractProjectiveSpace.
(The optional arguments are slightly different.)

See also
========

  * projectiveBundle' -- make a projective bundle
    from an abstract sheaf
  * abstractProjectiveSpace -- make a
    projective space
  * flagBundle -- make a flag bundle

Ways to use projectiveBundle:
=============================

  * "projectiveBundle(AbstractSheaf)"
  * "projectiveBundle(ZZ)"
  * "projectiveBundle(ZZ,AbstractVariety)"

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

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

projectiveBundle' -- make a projective bundle from an abstract sheaf
********************************************************************

Synopsis
========

  * Usage:
        projectiveBundle' F
        projectiveBundle'(n,X)
        projectiveBundle' n
  * Inputs:
      * F, an abstract sheaf,
      * n, an integer (Macaulay2Doc),
      * X, an abstract variety,
  * Optional inputs (Macaulay2Doc),:
      * VariableNames => a thing (Macaulay2Doc), default value
        null, see flagBundle(...,VariableNames=>...),
  * Outputs:
      * the projective bundle of rank 1 quotient bundles of the abstract sheaf
        $F$. If $F$ is omitted, then a projective space of dimension $n$ over
        $X$ is produced. If $X$ is omitted, then point, is used as
        the base.

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

+------------------------------------------------+
|i1 : X = projectiveBundle' 4                    |
|                                                |
|o1 = X                                          |
|                                                |
|o1 : a flag bundle with subquotient ranks {4, 1}|
+------------------------------------------------+
|i2 : F = OO_X(2) ++ OO_X(3) ++ OO_X(4)          |
|                                                |
|o2 = F                                          |
|                                                |
|o2 : an abstract sheaf of rank 3 on X           |
+------------------------------------------------+
|i3 : Y = projectiveBundle' F                    |
|                                                |
|o3 = Y                                          |
|                                                |
|o3 : a flag bundle with subquotient ranks {2, 1}|
+------------------------------------------------+
|i4 : dim Y                                      |
|                                                |
|o4 = 6                                          |
+------------------------------------------------+
|i5 : integral (chern_1 OO_Y(1))^(dim Y)         |
|                                                |
|o5 = 1351                                       |
+------------------------------------------------+
|i6 : bundles X/rank                             |
|                                                |
|o6 = (4, 1)                                     |
|                                                |
|o6 : Sequence                                   |
+------------------------------------------------+

Caveat
======

Perhaps this should be merged with abstractProjectiveSpace.
(The optional arguments are slightly different.)

See also
========

  * projectiveBundle -- make a projective bundle from
    an abstract sheaf
  * abstractProjectiveSpace -- make a
    projective space
  * flagBundle -- make a flag bundle

Ways to use projectiveBundle':
==============================

  * "projectiveBundle'(AbstractSheaf)"
  * "projectiveBundle'(ZZ)"
  * "projectiveBundle'(ZZ,AbstractVariety)"

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

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

PullBack -- a symbol used internally as a key for storing the pull back map in an abstract variety map
******************************************************************************************************

See also
========

  * AbstractVarietyMap ^* -- pull back operator
    associated to a map of varieties
  * extensionAlgebra -- extend a graded algebra by a
    graded module

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

The object PullBack, is a symbol (Macaulay2Doc).

QuotientBundles -- get the quotient bundles of the tautological filtration on a flag bundle
*******************************************************************************************

Synopsis
========

  * Usage:
        F.QuotientBundles
  * Inputs:
      * F, an abstract flag bundle,
  * Outputs:
      * a list (Macaulay2Doc), $\{E_n/E_n, E_n/E_{n-1}, ...,
        E_n/E_1, E_n/E_0\}$ whose elements are the quotient bundles in the
        tautological filtration $0 = E_0 \subseteq{} E_1 \subseteq{} ...
        \subseteq{} E_n = f^* B$, where $F$ is a flag bundle parametrizing
        filtrations of an abstract sheaf $B$ on a variety $X$, and $f : F
        \rightarrow X$ is the structure map of $F$

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

+-------------------------------------------------------+
|i1 : F = flagBundle {1,1,2}                            |
|                                                       |
|o1 = F                                                 |
|                                                       |
|o1 : a flag bundle with subquotient ranks {2:1, 2}     |
+-------------------------------------------------------+
|i2 : F.QuotientBundles                                 |
|                                                       |
|o2 = {a sheaf, a sheaf, a sheaf, a sheaf}              |
|                                                       |
|o2 : List                                              |
+-------------------------------------------------------+
|i3 : rank \ oo                                         |
|                                                       |
|o3 = {0, 2, 3, 4}                                      |
|                                                       |
|o3 : List                                              |
+-------------------------------------------------------+
|i4 : netList \\ chern \ ooo                            |
|                                                       |
|     +------------------------------------------------+|
|o4 = |1                                               ||
|     +------------------------------------------------+|
|     |1 + H    + H                                    ||
|     |     3,1    3,2                                 ||
|     +------------------------------------------------+|
|     |1 + (H    + H   ) + (H   H    + H   ) + H   H   ||
|     |      2,1    3,1      2,1 3,1    3,2     2,1 3,2||
|     +------------------------------------------------+|
|     |1                                               ||
|     +------------------------------------------------+|
+-------------------------------------------------------+

Functions with optional argument named QuotientBundles:
=======================================================

  * "flagBundle(...,QuotientBundles=>...)" -- see flagBundle,
    -- make a flag bundle

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

The object QuotientBundles, is a symbol (Macaulay2Doc).

rank(AbstractSheaf)
*******************

Synopsis
========

  * Function: rank (Macaulay2Doc),
  * Usage:
        rank F
  * Inputs:
      * F,
  * Outputs:
      * the rank of F

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

+-------------------------------------------------+
|i1 : rank tangentBundle abstractProjectiveSpace 4|
|                                                 |
|o1 = 4                                           |
+-------------------------------------------------+

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

  * rank(AbstractSheaf)

Ring _ ChernClassVariable -- get a ring generator corresponding to a Chern class variable
*****************************************************************************************

Synopsis
========

  * Operator: _ (Macaulay2Doc),
  * Usage:
        R_v
  * Inputs:
      * R,
      * v,
  * Outputs:
      * the generator of R corresponding to v

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

+------------------------------------------+
|i1 : x = chern_3 E                        |
|                                          |
|o1 = c E                                  |
|      3                                   |
|                                          |
|o1 : ChernClassVariable                   |
+------------------------------------------+
|i2 : R = QQ[chern_1 E,chern_2 E,chern_3 E]|
|                                          |
|o2 = R                                    |
|                                          |
|o2 : PolynomialRing                       |
+------------------------------------------+
|i3 : R_x                                  |
|                                          |
|o3 = c E                                  |
|      3                                   |
|                                          |
|o3 : R                                    |
+------------------------------------------+

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

  * Ring _ ChernClassVariable -- get a ring
    generator corresponding to a Chern class variable

schubertCycle -- compute Schubert Cycles on a Grassmannian, Fulton-style
************************************************************************

Synopsis
========

  * Usage:
        schubertCycle(s,F)
  * Inputs:
      * F, an abstract flag bundle, associated to a vector
        bundle $A$, say, of rank $n$. This flag bundle should be a
        Grassmannian, parametrizing rank $r$ sub-bundles of $A$, say.
      * s, a sequence (Macaulay2Doc), $(s_0, ..., s_{r-1})$ of
        length $r$ of integers, with $0 \le{} s_0 < ... < s_{r-1} < n$, or a
        list (Macaulay2Doc),  $\{s_0, ..., s_{r-1}\}$ of length $r$
        of integers, with $n-r \ge{} s_0 \ge{} ... \ge{} s_{r-1} \ge{} 0$
  * Outputs:
      * c, the appropriate Schubert class or Schubert variety, depending on the
        type of s.  See page 271 of Fulton's book, Intersection Theory for the
        notations.  In the case where s is a a sequence (Macaulay2Doc),
        the value returned is the homology class of
        the Schubert variety in $ F $ consisting of those points corresponding
        to $(r-1)$-planes of $\PP(A)$ that meet $ W_j $ in dimension at least $
        i $ with $0 \le{} i < r-1$, for each $ i $, where $ j = s_i $, and
        where $ W_j $ is the projective subspace of dimension $ j $ in a fixed
        (complete) flag $0 = W_0 \subset{} W_1 \subset{} ... \subset{} W_{n-1}
        = \PP(A) $.  Here $ \PP(A) $ denotes the "Fulton-style"  projective
        bundle parametrizing rank 1 sub-bundles of $A$; for opposite
        "Grothendieck-style" version, see schubertCycle'.
        In the case where s is a a list (Macaulay2Doc),
        the result is the corresponding Schubert class in
        cohomology.  In Schubert2 homology and cohomology are identified with
        each other. Given a sequence $(s_0, ..., s_{r-1})$, one can convert it
        to a list yielding the same Schubert class by the formula $ \{...,
        n-r+i-s_i, ...\} $.

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

+------------------------------------------------+
|i1 : base(0, Bundle=>(A, n=8, a))               |
|                                                |
|o1 = a variety                                  |
|                                                |
|o1 : an abstract variety of dimension 0         |
+------------------------------------------------+
|i2 : F = flagBundle ({r=5,3},A)                 |
|                                                |
|o2 = F                                          |
|                                                |
|o2 : a flag bundle with subquotient ranks {5, 3}|
+------------------------------------------------+
|i3 : CH = intersectionRing F;                   |
+------------------------------------------------+
|i4 : schubertCycle((0,1,5,6,7),F)               |
|                                                |
|      2                                         |
|o4 = H                                          |
|      2,3                                       |
|                                                |
|o4 : CH                                         |
+------------------------------------------------+
|i5 : {n-r+0-0,n-r+1-1,n-r+2-5,n-r+3-6,n-r+4-7}  |
|                                                |
|o5 = {3, 3, 0, 0, 0}                            |
|                                                |
|o5 : List                                       |
+------------------------------------------------+
|i6 : schubertCycle(oo,F)                        |
|                                                |
|      2                                         |
|o6 = H                                          |
|      2,3                                       |
|                                                |
|o6 : CH                                         |
+------------------------------------------------+

Ways to use schubertCycle:
==========================

  * "schubertCycle(List,FlagBundle)"
  * "schubertCycle(Sequence,FlagBundle)"

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

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

schubertCycle' -- compute Schubert Cycles on a Grassmannian, Grothendieck-style
*******************************************************************************

Synopsis
========

  * Usage:
        schubertCycle'(s,F)
        F_s
  * Inputs:
      * F, an abstract flag bundle, associated to a vector
        bundle $A$, say, of rank $n$. This flag bundle should be a
        Grassmannian, parametrizing rank $q$ quotient bundles of $A$, say.
      * s, a sequence (Macaulay2Doc), $(s_0, ..., s_{q-1})$ of
        length $q$ of integers, with $0 \le{} s_0 < ... < s_{q-1} < n$, or a
        list (Macaulay2Doc),  $\{s_0, ..., s_{q-1}\}$ of length $q$
        of integers, with $n-q \ge{} s_0 \ge{} ... \ge{} s_{q-1} \ge{} 0$
  * Outputs:
      * c, the appropriate Schubert class or Schubert variety, depending on the
        type of s.  See page 271 of Fulton's book, Intersection Theory for the
        notation for schubertCycle, of which this is the
        dual.  In the case where s is a a sequence (Macaulay2Doc),
        the value returned is the homology class of
        the Schubert variety in $ F $ consisting of those points corresponding
        to $(q-1)$-planes of $\PP(A)$ that meet $ W_j $ in dimension at least $
        i $ with $0 \le{} i < q$, for each $ i $, where $ j = s_i $, and where
        $ W_j $ is the projective subspace of dimension $ j $ in a fixed
        (complete) flag $0 = W_0 \subset{} W_1 \subset{} ... \subset{} W_{n-1}
        = \PP(A) $.  Here $ \PP(A) $ denotes the modern Grothendieck-style
        projective bundle parametrizing rank 1 quotient bundles of $A$; for the
        older "Fulton-style" version, see schubertCycle.
        In the case where s is a a list (Macaulay2Doc), the result
        is the corresponding Schubert class in cohomology.  In Schubert2
        homology and cohomology are identified with each other. Given a
        sequence $(s_0, ..., s_{q-1})$, one can convert it to a list yielding
        the same Schubert class by the formula $ \{..., n-q+i-s_i, ...\} $.
        This is related to schubertCycle, as follows: if
        $E'$ is the dual bundle of $A$ and $G' = G(q,A')$ is the dual
        Grassmannian, then schubertCycle'(s,G) is carried to
        schubertCycle(s,G') under the duality isomorphism.

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

+------------------------------------------------+
|i1 : base(0, Bundle=>(A, n=8, a))               |
|                                                |
|o1 = a variety                                  |
|                                                |
|o1 : an abstract variety of dimension 0         |
+------------------------------------------------+
|i2 : F = flagBundle ({5,q=3},A)                 |
|                                                |
|o2 = F                                          |
|                                                |
|o2 : a flag bundle with subquotient ranks {5, 3}|
+------------------------------------------------+
|i3 : CH = intersectionRing F;                   |
+------------------------------------------------+
|i4 : F_(1,3,5)                                  |
|                                                |
|              2      3                          |
|o4 = H   H   H    - H                           |
|      2,1 2,2 2,3    2,3                        |
|                                                |
|o4 : CH                                         |
+------------------------------------------------+
|i5 : {n-q+0-1,n-q+1-3,n-q+2-5}                  |
|                                                |
|o5 = {4, 3, 2}                                  |
|                                                |
|o5 : List                                       |
+------------------------------------------------+
|i6 : F_oo                                       |
|                                                |
|              2      3                          |
|o6 = H   H   H    - H                           |
|      2,1 2,2 2,3    2,3                        |
|                                                |
|o6 : CH                                         |
+------------------------------------------------+

Ways to use schubertCycle':
===========================

  * "schubertCycle'(List,FlagBundle)"
  * "schubertCycle'(Sequence,FlagBundle)"

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

The object schubertCycle', is a method function (Macaulay2Doc).

SchubertRing -- a symbol used internally as a key
*************************************************

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

If $G$ is a Grassmannian (i.e. a FlagBundle, with rank
sequence of length 2), and if the Schubert ring of $G$ has already been built,
then it is stored in G.cache.SchubertRing. This should not be used as an
accessor; see schubertRing.

See also
========

  * schubertRing -- get the Schubert ring of a
    Grassmannian

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

The object SchubertRing, is a symbol (Macaulay2Doc).

schubertRing -- get the Schubert ring of a Grassmannian
*******************************************************

Synopsis
========

  * Usage:
        schubertRing G
  * Inputs:
      * G, an abstract flag bundle, a Grassmannian, with
        intersection ring $R$, say
  * Outputs:
      * A triple $(S,T,U)$, where $S$ is the Schubert ring of $G$, with
        generators corresponding to the (Fulton-style) Schubert cycles of $G$
        and with multiplication corresponding to multiplication in the
        intersection ring of $G$, $T$ is the map from $R$ to $S$ converting
        from the Chern class basis to the Schubert basis, and $U$ is the
        inverse map to $T$.
  * Consequences:
      * When run for the first time on $G$, the Schubert ring $S$ is built and
        cached in G.cache.SchubertRing, see SchubertRing,
        $T$ is built and cached in G.cache.htoschubert, and $U$ is built and
        cached in G.cache.schuberttoh.

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

+-----------------------------------------------------------------------------+
|i1 : G = flagBundle({2,2})                                                   |
|                                                                             |
|o1 = G                                                                       |
|                                                                             |
|o1 : a flag bundle with subquotient ranks {2:2}                              |
+-----------------------------------------------------------------------------+
|i2 : (S,T,U) = schubertRing G                                                |
|                                                                             |
|                                               QQ[][H   ..H   ]              |
|                                                     1,1   2,2               |
|o2 = (S, T, map (------------------------------------------------------------|
|                 (- H    - H   , - H    - H   H    - H   , - H   H    - H   H|
|                     1,1    2,1     1,2    1,1 2,1    2,2     1,2 2,1    1,1 |
|     ------------------------------------------------------------------------|
|                                    2                            2           |
|     ---------------, S, {1, H   , H    - H   , H   , H   H   , H   }))      |
|        , -H   H   )          2,1   2,1    2,2   2,2   2,1 2,2   2,2         |
|     2,2    1,2 2,2                                                          |
|                                                                             |
|o2 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i3 : c = schubertCycle({1,0},G)                                              |
|                                                                             |
|o3 = H                                                                       |
|      2,1                                                                    |
|                                                                             |
|                                   QQ[][H   ..H   ]                          |
|                                         1,1   2,2                           |
|o3 : ------------------------------------------------------------------------|
|     (- H    - H   , - H    - H   H    - H   , - H   H    - H   H   , -H   H |
|         1,1    2,1     1,2    1,1 2,1    2,2     1,2 2,1    1,1 2,2    1,2 2|
|-----------------------------------------------------------------------------|
|---                                                                          |
|  )                                                                          |
|,2                                                                           |
+-----------------------------------------------------------------------------+
|i4 : a = T c                                                                 |
|                                                                             |
|o4 = s                                                                       |
|      {1, 0}                                                                 |
|                                                                             |
|o4 : Schubert Basis of G(2,4) over point                                     |
+-----------------------------------------------------------------------------+
|i5 : a^2                                                                     |
|                                                                             |
|o5 = s       + s                                                             |
|      {1, 1}    {2, 0}                                                       |
|                                                                             |
|o5 : Schubert Basis of G(2,4) over point                                     |
+-----------------------------------------------------------------------------+
|i6 : U oo                                                                    |
|                                                                             |
|      2                                                                      |
|o6 = H                                                                       |
|      2,1                                                                    |
|                                                                             |
|                                   QQ[][H   ..H   ]                          |
|                                         1,1   2,2                           |
|o6 : ------------------------------------------------------------------------|
|     (- H    - H   , - H    - H   H    - H   , - H   H    - H   H   , -H   H |
|         1,1    2,1     1,2    1,1 2,1    2,2     1,2 2,1    1,1 2,2    1,2 2|
|-----------------------------------------------------------------------------|
|---                                                                          |
|  )                                                                          |
|,2                                                                           |
+-----------------------------------------------------------------------------+

See also
========

  * toSchubertBasis -- express cycles on a Grassmannian
    in terms of the Schubert basis

Ways to use schubertRing:
=========================

  * "schubertRing(FlagBundle)"

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

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

schur(List,AbstractSheaf) -- apply a Schur functor to an abstract sheaf
***********************************************************************

Synopsis
========

  * Function: schur,
  * Usage:
        schur(p,E)
        schur_p E
  * Inputs:
      * p, a partition, specified by a descending list of non-negative integers
      * E,
  * Outputs:
      * the result of applying the Schur functor corresponding to the partition
        $p$ to $E$

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

+-------------------------------------------------------+
|i1 : base(3, Bundle => (E,3,c))                        |
|                                                       |
|o1 = a variety                                         |
|                                                       |
|o1 : an abstract variety of dimension 3                |
+-------------------------------------------------------+
|i2 : chern E                                           |
|                                                       |
|o2 = 1 + c  + c  + c                                   |
|          1    2    3                                  |
|                                                       |
|o2 : QQ[c ..c ]                                        |
|         1   3                                         |
+-------------------------------------------------------+
|i3 : chern schur_{1,1,1} E                             |
|                                                       |
|o3 = 1 + c                                             |
|          1                                            |
|                                                       |
|o3 : QQ[c ..c ]                                        |
|         1   3                                         |
+-------------------------------------------------------+
|i4 : chern schur_{2,1} E                               |
|                                                       |
|                   2              3                    |
|o4 = 1 + 8c  + (26c  + 6c ) + (44c  + 36c c )          |
|           1       1     2        1      1 2           |
|                                                       |
|o4 : QQ[c ..c ]                                        |
|         1   3                                         |
+-------------------------------------------------------+
|i5 : chern schur_{3} E                                 |
|                                                       |
|                    2               3                  |
|o5 = 1 + 10c  + (40c  + 15c ) + (82c  + 111c c  + 27c )|
|            1       1      2        1       1 2      3 |
|                                                       |
|o5 : QQ[c ..c ]                                        |
|         1   3                                         |
+-------------------------------------------------------+

See also
========

  * exteriorPower(ZZ,AbstractSheaf)
  * symmetricPower(RingElement,AbstractSheaf)
    -- symmetric power of an
    abstract sheaf

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

  * schur(List,AbstractSheaf) -- apply
    a Schur functor to an abstract sheaf

SectionClass -- a symbol used internally as a key
*************************************************

See also
========

  * sectionClass -- get the class
    of the image of a section of a map of abstract varieties

Functions with optional argument named SectionClass:
====================================================

  * "abstractVarietyMap(...,SectionClass=>...)" -- see
    abstractVarietyMap, -- make an abstract variety
    morphism

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

The object SectionClass, is a symbol (Macaulay2Doc).

sectionClass(AbstractVarietyMap) -- get the class of the image of a section of a map of abstract varieties
**********************************************************************************************************

Synopsis
========

  * Function: sectionClass,
  * Usage:
        sectionClass f
  * Inputs:
      * f,
  * Outputs:
      * the class of a section of $f$.  (This means, more or less, any cycle
        class of relative dimension zero whose integral is 1.)

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

+-----------------------------------------------------------------------------+
|i1 : X = abstractProjectiveSpace 4                                           |
|                                                                             |
|o1 = X                                                                       |
|                                                                             |
|o1 : a flag bundle with subquotient ranks {1, 4}                             |
+-----------------------------------------------------------------------------+
|i2 : f = X.StructureMap                                                      |
|                                                                             |
|o2 = f                                                                       |
|                                                                             |
|o2 : a map to point from X                                                   |
+-----------------------------------------------------------------------------+
|i3 : sectionClass f                                                          |
|                                                                             |
|o3 = H                                                                       |
|      2,4                                                                    |
|                                                                             |
|                                QQ[][h, H   ..H   ]                          |
|                                         2,1   2,4                           |
|o3 : ------------------------------------------------------------------------|
|     (- h - H   , - h*H    - H   , - h*H    - H   , - h*H    - H   , -h*H   )|
|             2,1       2,1    2,2       2,2    2,3       2,3    2,4      2,4 |
+-----------------------------------------------------------------------------+
|i4 : integral oo                                                             |
|                                                                             |
|o4 = 1                                                                       |
+-----------------------------------------------------------------------------+
|i5 : G = flagBundle {2,2}                                                    |
|                                                                             |
|o5 = G                                                                       |
|                                                                             |
|o5 : a flag bundle with subquotient ranks {2:2}                              |
+-----------------------------------------------------------------------------+
|i6 : G.StructureMap                                                          |
|                                                                             |
|o6 = a variety map                                                           |
|                                                                             |
|o6 : a map to point from G                                                   |
+-----------------------------------------------------------------------------+
|i7 : sectionClass oo                                                         |
|                                                                             |
|      2                                                                      |
|o7 = H                                                                       |
|      2,2                                                                    |
|                                                                             |
|                                   QQ[][H   ..H   ]                          |
|                                         1,1   2,2                           |
|o7 : ------------------------------------------------------------------------|
|     (- H    - H   , - H    - H   H    - H   , - H   H    - H   H   , -H   H |
|         1,1    2,1     1,2    1,1 2,1    2,2     1,2 2,1    1,1 2,2    1,2 2|
|-----------------------------------------------------------------------------|
|---                                                                          |
|  )                                                                          |
|,2                                                                           |
+-----------------------------------------------------------------------------+
|i8 : integral oo                                                             |
|                                                                             |
|o8 = 1                                                                       |
+-----------------------------------------------------------------------------+

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

  * sectionClass(AbstractVarietyMap)
    -- get the class of the image of a
    section of a map of abstract varieties

sectionZeroLocus(AbstractSheaf)
*******************************

Synopsis
========

  * Function: sectionZeroLocus,
  * Usage:
        sectionZeroLocus F
  * Inputs:
      * F,
  * Outputs:
      * the zero locus of a generic section of F

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

+-----------------------------------------------------------------------------+
|i1 : X = base(5, n, Bundle => (E,3,c), Bundle => (T,5,t), Bundle =>          |
|                                                                             |
|o1 = X                                                                       |
|                                                                             |
|o1 : an abstract variety of dimension 5                                      |
|-----------------------------------------------------------------------------|
|(L,1,{h}))                                                                   |
+-----------------------------------------------------------------------------+
|i2 : X.TangentBundle = T                                                     |
|                                                                             |
|o2 = T                                                                       |
|                                                                             |
|o2 : an abstract sheaf of rank 5 on X                                        |
+-----------------------------------------------------------------------------+
|i3 : Y = sectionZeroLocus E                                                  |
|                                                                             |
|o3 = Y                                                                       |
|                                                                             |
|o3 : an abstract variety of dimension 2                                      |
+-----------------------------------------------------------------------------+
|i4 : Y.TautologicalLineBundle = OO_Y(h)                                      |
|                                                                             |
|o4 = a sheaf                                                                 |
|                                                                             |
|o4 : an abstract sheaf of rank 1 on Y                                        |
+-----------------------------------------------------------------------------+
|i5 : chern tangentBundle Y                                                   |
|                                                                             |
|                         2                                                   |
|o5 = 1 + (- c  + t ) + (c  - c t  - c  + t )                                 |
|             1    1      1    1 1    2    2                                  |
|                                                                             |
|o5 : QQ[n, c ..c , t ..t , h][]                                              |
|            1   3   1   5                                                    |
+-----------------------------------------------------------------------------+
|i6 : integral oo                                                             |
|                                                                             |
|               2                                                             |
|o6 = integral(c c  - c c t  - c c  + c t )                                   |
|               1 3    1 3 1    2 3    3 2                                    |
|                                                                             |
|o6 : Expression of class Adjacent                                            |
+-----------------------------------------------------------------------------+
|i7 : chi ((tangentBundle Y)(n))                                              |
|                                                                             |
|               2   2                         1 2     3         7   2   5     |
|o7 = integral(n c h  - 2n*c c h + 2n*c t h + -c c  - -c c t  + -c t  + -c c  |
|                 3         1 3        3 1    3 1 3   2 1 3 1   6 3 1   6 2 3 |
|                                                                             |
|o7 : Expression of class Adjacent                                            |
|-----------------------------------------------------------------------------|
|  5                                                                          |
|- -c t )                                                                     |
|  6 3 2                                                                      |
+-----------------------------------------------------------------------------+

Caveat
======

The intersection ring provided for the zero locus contains only those classes
arising by pull-back from the ambient variety: there is no algorithm to compute
the intersection ring.

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

  * sectionZeroLocus(AbstractSheaf)

segre -- compute Segre classes of a sheaf
*****************************************

Ways to use segre:
==================

  * segre(AbstractSheaf) -- compute the total
    Segre class of a sheaf
  * segre(ZZ,AbstractSheaf) -- compute a
    Segre class of a sheaf

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

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

segre(AbstractSheaf) -- compute the total Segre class of a sheaf
****************************************************************

Synopsis
========

  * Function: segre,
  * Usage:
        segre A
  * Inputs:
      * A,
  * Outputs:
      * the total Segre class of A, defined as the reciprocal of the Chern
        class of the dual of A.  (In a future version, the dual may be omitted,
        and an alternative function segre' may be introduced.)

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

+-----------------------------------------------------------------------+
|i1 : base(4, Bundle => (B,3,b))                                        |
|                                                                       |
|o1 = a variety                                                         |
|                                                                       |
|o1 : an abstract variety of dimension 4                                |
+-----------------------------------------------------------------------+
|i2 : chern B                                                           |
|                                                                       |
|o2 = 1 + b  + b  + b                                                   |
|          1    2    3                                                  |
|                                                                       |
|o2 : QQ[b ..b ]                                                        |
|         1   3                                                         |
+-----------------------------------------------------------------------+
|i3 : segre B                                                           |
|                                                                       |
|                2           3                   4     2      2         |
|o3 = 1 + b  + (b  - b ) + (b  - 2b b  + b ) + (b  - 3b b  + b  + 2b b )|
|          1     1    2      1     1 2    3      1     1 2    2     1 3 |
|                                                                       |
|o3 : QQ[b ..b ]                                                        |
|         1   3                                                         |
+-----------------------------------------------------------------------+

See also
========

  * chern -- compute Chern classes of a sheaf

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

  * segre(AbstractSheaf) -- compute the total
    Segre class of a sheaf

segre(ZZ,AbstractSheaf) -- compute a Segre class of a sheaf
***********************************************************

Synopsis
========

  * Function: segre,
  * Usage:
        segre(n,A)
        segre_n A
  * Inputs:
      * n,
      * A,
  * Outputs:
      * the n-th Segre class of A

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

+--------------------------------------------------+
|i1 : base(3, Bundle => (A,2,a), Bundle => (B,3,b))|
|                                                  |
|o1 = a variety                                    |
|                                                  |
|o1 : an abstract variety of dimension 3           |
+--------------------------------------------------+
|i2 : segre_3 B                                    |
|                                                  |
|      3                                           |
|o2 = b  - 2b b  + b                               |
|      1     1 2    3                              |
|                                                  |
|o2 : QQ[a ..a , b ..b ]                           |
|         1   2   1   3                            |
+--------------------------------------------------+
|i3 : segre(2,A**B)                                |
|                                                  |
|       2                   2                      |
|o3 = 6a  - 3a  + 7a b  + 3b  - 2b                 |
|       1     2     1 1     1     2                |
|                                                  |
|o3 : QQ[a ..a , b ..b ]                           |
|         1   2   1   3                            |
+--------------------------------------------------+

See also
========

  * chern(ZZ,AbstractSheaf) -- compute a
    Chern class of a sheaf

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

  * segre(ZZ,AbstractSheaf) -- compute a
    Segre class of a sheaf

source(AbstractVarietyMap) -- the source of a map of abstract varieties
***********************************************************************

Synopsis
========

  * Function: source (Macaulay2Doc),
  * Usage:
        source f
  * Inputs:
      * f,
  * Outputs:
      * the source of f

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

+------------------------------------------------+
|i1 : X = abstractProjectiveSpace 4              |
|                                                |
|o1 = X                                          |
|                                                |
|o1 : a flag bundle with subquotient ranks {1, 4}|
+------------------------------------------------+
|i2 : f = X.StructureMap                         |
|                                                |
|o2 = f                                          |
|                                                |
|o2 : a map to point from X                      |
+------------------------------------------------+
|i3 : source f                                   |
|                                                |
|o3 = X                                          |
|                                                |
|o3 : a flag bundle with subquotient ranks {1, 4}|
+------------------------------------------------+

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

  * source(AbstractVarietyMap) -- the
    source of a map of abstract varieties

source(Correspondence) -- the source of a correspondence
********************************************************

Synopsis
========

  * Function: source (Macaulay2Doc),

See also
========

  * Correspondence -- the class of all correspondences

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

  * source(Correspondence) -- the source of
    a correspondence

StructureMap -- get the structure map of an abstract variety
************************************************************

Synopsis
========

  * Usage:
        F.StructureMap
  * Inputs:
      * F, an abstract variety,
  * Outputs:
      * an abstract variety map, the structure map
        of $F$, if it has one.

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

+------------------------------------------------+
|i1 : F = abstractProjectiveSpace 2              |
|                                                |
|o1 = F                                          |
|                                                |
|o1 : a flag bundle with subquotient ranks {1..2}|
+------------------------------------------------+
|i2 : f = F.StructureMap                         |
|                                                |
|o2 = f                                          |
|                                                |
|o2 : a map to point from F                      |
+------------------------------------------------+
|i3 : source f                                   |
|                                                |
|o3 = F                                          |
|                                                |
|o3 : a flag bundle with subquotient ranks {1..2}|
+------------------------------------------------+
|i4 : f_* OO_F                                   |
|                                                |
|o4 = a sheaf                                    |
|                                                |
|o4 : an abstract sheaf of rank 1 on point       |
+------------------------------------------------+
|i5 : f_* OO_F(1)                                |
|                                                |
|o5 = a sheaf                                    |
|                                                |
|o5 : an abstract sheaf of rank 3 on point       |
+------------------------------------------------+
|i6 : target f                                   |
|                                                |
|o6 = point                                      |
|                                                |
|o6 : an abstract variety of dimension 0         |
+------------------------------------------------+
|i7 : f^* OO_point                               |
|                                                |
|o7 = a sheaf                                    |
|                                                |
|o7 : an abstract sheaf of rank 1 on F           |
+------------------------------------------------+

See also
========

  * AbstractVariety / AbstractVariety,
    -- get a structure map

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

The object StructureMap, is a symbol (Macaulay2Doc).

SubBundles -- get the subbundles of the tautological filtration on a flag bundle
********************************************************************************

Synopsis
========

  * Usage:
        F.SubBundles
  * Inputs:
      * F, an abstract flag bundle,
  * Outputs:
      * a list (Macaulay2Doc), whose elements are the subbundles $0
        = E_0 \subseteq{} E_1 \subseteq{} ... \subseteq{} E_n = f^* B$ in the
        tautological filtration of $f^* B$, where $F$ is a flag bundle
        parametrizing filtrations of an abstract sheaf $B$ on a variety $X$,
        and $f : F \rightarrow X$ is the structure map of $F$

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

+--------------------------------------------------+
|i1 : F = flagBundle {1,1,2}                       |
|                                                  |
|o1 = F                                            |
|                                                  |
|o1 : a flag bundle with subquotient ranks {2:1, 2}|
+--------------------------------------------------+
|i2 : F.SubBundles                                 |
|                                                  |
|o2 = {a sheaf, a sheaf, a sheaf, a sheaf}         |
|                                                  |
|o2 : List                                         |
+--------------------------------------------------+
|i3 : rank \ oo                                    |
|                                                  |
|o3 = {0, 1, 2, 4}                                 |
|                                                  |
|o3 : List                                         |
+--------------------------------------------------+
|i4 : netList \\ chern \ ooo                       |
|                                                  |
|     +------------------------+                   |
|o4 = |1                       |                   |
|     +------------------------+                   |
|     |1 + (- H    - H   )     |                   |
|     |        2,1    3,1      |                   |
|     +------------------------+                   |
|     |             2          |                   |
|     |1 - H    + (H    - H   )|                   |
|     |     3,1     3,1    3,2 |                   |
|     +------------------------+                   |
|     |1                       |                   |
|     +------------------------+                   |
+--------------------------------------------------+

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

The object SubBundles, is a symbol (Macaulay2Doc).

symmetricPower(RingElement,AbstractSheaf) -- symmetric power of an abstract sheaf
*********************************************************************************

Synopsis
========

  * Function: symmetricPower (Macaulay2Doc),
  * Usage:
        symmetricPower(n,F)
        symmetricPower_n F
  * Inputs:
      * n,
      * F,
  * Outputs:
      * the $n$-th symmetric power of $F$

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

In the first example, we let $n$ be a natural number.

+-----------------------------------------------------------------------------+
|i1 : tangentBundle abstractProjectiveSpace 4                                 |
|                                                                             |
|o1 = a sheaf                                                                 |
|                                                                             |
|o1 : an abstract sheaf of rank 4 on a flag bundle                            |
+-----------------------------------------------------------------------------+
|i2 : symmetricPower_4 oo                                                     |
|                                                                             |
|o2 = a sheaf                                                                 |
|                                                                             |
|o2 : an abstract sheaf of rank 35 on a flag bundle                           |
+-----------------------------------------------------------------------------+
|i3 : chern oo                                                                |
|                                                                             |
|o3 = 1 + 175H    + 14910H    + 823970H    + 33198935H                        |
|             2,1         2,2          2,3            2,4                     |
|                                                                             |
|                                QQ[][h, H   ..H   ]                          |
|                                         2,1   2,4                           |
|o3 : ------------------------------------------------------------------------|
|     (- h - H   , - h*H    - H   , - h*H    - H   , - h*H    - H   , -h*H   )|
|             2,1       2,1    2,2       2,2    2,3       2,3    2,4      2,4 |
+-----------------------------------------------------------------------------+

In the next example, we let $n$ be a free parameter in the ``intersection
ring'' of the base variety.

+------------------------------------------------+
|i4 : pt = base n                                |
|                                                |
|o4 = pt                                         |
|                                                |
|o4 : an abstract variety of dimension 0         |
+------------------------------------------------+
|i5 : X = abstractProjectiveSpace'_2 pt          |
|                                                |
|o5 = X                                          |
|                                                |
|o5 : a flag bundle with subquotient ranks {2, 1}|
+------------------------------------------------+
|i6 : tangentBundle X                            |
|                                                |
|o6 = a sheaf                                    |
|                                                |
|o6 : an abstract sheaf of rank 2 on X           |
+------------------------------------------------+
|i7 : F = symmetricPower_n oo                    |
|                                                |
|o7 = F                                          |
|                                                |
|o7 : an abstract sheaf of rank n + 1 on X       |
+------------------------------------------------+
|i8 : chern F                                    |
|                                                |
|          3 2   3       9 4   5 3   3 2   1   2 |
|o8 = 1 + (-n  + -n)h + (-n  + -n  + -n  + -n)h  |
|          2     2       8     4     8     4     |
|                                                |
|             QQ[n][H   ..H   , h]               |
|                    1,1   1,2                   |
|o8 : ------------------------------------       |
|     (- H    - h, - H    - H   h, -H   h)       |
|         1,1         1,2    1,1     1,2         |
+------------------------------------------------+
|i9 : ch F                                       |
|                                                |
|                3 2   3        3   3 2   1   2  |
|o9 = (n + 1) + (-n  + -n)h + (n  + -n  - -n)h   |
|                2     2            4     4      |
|                                                |
|             QQ[n][H   ..H   , h]               |
|                    1,1   1,2                   |
|o9 : ------------------------------------       |
|     (- H    - h, - H    - H   h, -H   h)       |
|         1,1         1,2    1,1     1,2         |
+------------------------------------------------+
|i10 : chi F                                     |
|                                                |
|       3     2                                  |
|o10 = n  + 3n  + 3n + 1                         |
|                                                |
|o10 : QQ[n]                                     |
+------------------------------------------------+

See also
========

  * exteriorPower(ZZ,AbstractSheaf)
  * schur(List,AbstractSheaf) -- apply
    a Schur functor to an abstract sheaf

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

  * symmetricPower(RingElement,AbstractSheaf)
    -- symmetric power of an
    abstract sheaf

TangentBundle -- a symbol used internally as a key
**************************************************

See also
========

  * tangentBundle -- get the tangent bundle

Functions with optional argument named TangentBundle:
=====================================================

  * "abstractVarietyMap(...,TangentBundle=>...)" -- see
    abstractVarietyMap, -- make an abstract variety
    morphism

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

The object TangentBundle, is a symbol (Macaulay2Doc).

tangentBundle -- get the tangent bundle
***************************************

Synopsis
========

  * Usage:
        tangentBundle X
        tangentBundle f
  * Inputs:
      * X, an abstract variety,
      * f, an abstract variety map,
  * Outputs:
      * an abstract sheaf, the (absolute) tangent bundle
        of $X$ or the (relative) tangent bundle of $f$

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

+----------------------------------------------------------------+
|i1 : X = abstractProjectiveSpace' 2                             |
|                                                                |
|o1 = X                                                          |
|                                                                |
|o1 : a flag bundle with subquotient ranks {2, 1}                |
+----------------------------------------------------------------+
|i2 : Y = abstractProjectiveSpace'_2 X                           |
|                                                                |
|o2 = Y                                                          |
|                                                                |
|o2 : a flag bundle with subquotient ranks {2, 1}                |
+----------------------------------------------------------------+
|i3 : tangentBundle Y                                            |
|                                                                |
|o3 = a sheaf                                                    |
|                                                                |
|o3 : an abstract sheaf of rank 4 on Y                           |
+----------------------------------------------------------------+
|i4 : chern oo                                                   |
|                                                                |
|                        2            2         2     2       2 2|
|o4 = 1 + (3h + 3h) + (3h  + 9h*h + 3h ) + (9h*h  + 9h h) + 9h h |
|                                                                |
|              QQ[][H   ..H   , h]                               |
|                    1,1   1,2                                   |
|     ------------------------------------[H   ..H   , h]        |
|     (- H    - h, - H    - H   h, -H   h)  1,1   1,2            |
|         1,1         1,2    1,1     1,2                         |
|o4 : ---------------------------------------------------        |
|             (- H    - h, - H    - H   h, -H   h)               |
|                 1,1         1,2    1,1     1,2                 |
+----------------------------------------------------------------+
|i5 : tangentBundle Y.StructureMap                               |
|                                                                |
|o5 = a sheaf                                                    |
|                                                                |
|o5 : an abstract sheaf of rank 2 on Y                           |
+----------------------------------------------------------------+
|i6 : chern oo                                                   |
|                                                                |
|                2                                               |
|o6 = 1 + 3h + 3h                                                |
|                                                                |
|              QQ[][H   ..H   , h]                               |
|                    1,1   1,2                                   |
|     ------------------------------------[H   ..H   , h]        |
|     (- H    - h, - H    - H   h, -H   h)  1,1   1,2            |
|         1,1         1,2    1,1     1,2                         |
|o6 : ---------------------------------------------------        |
|             (- H    - h, - H    - H   h, -H   h)               |
|                 1,1         1,2    1,1     1,2                 |
+----------------------------------------------------------------+

See also
========

  * cotangentBundle -- get the cotangent bundle

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

  * "tangentBundle(AbstractVariety)"
  * "tangentBundle(AbstractVarietyMap)"

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

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

target(AbstractVarietyMap) -- the target of a map of abstract varieties
***********************************************************************

Synopsis
========

  * Function: target (Macaulay2Doc),
  * Usage:
        target f
  * Inputs:
      * f,
  * Outputs:
      * the target of f

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

+------------------------------------------------+
|i1 : X = abstractProjectiveSpace 4              |
|                                                |
|o1 = X                                          |
|                                                |
|o1 : a flag bundle with subquotient ranks {1, 4}|
+------------------------------------------------+
|i2 : f = X.StructureMap                         |
|                                                |
|o2 = f                                          |
|                                                |
|o2 : a map to point from X                      |
+------------------------------------------------+
|i3 : target f                                   |
|                                                |
|o3 = point                                      |
|                                                |
|o3 : an abstract variety of dimension 0         |
+------------------------------------------------+

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

  * target(AbstractVarietyMap) -- the
    target of a map of abstract varieties

target(Correspondence) -- the target of a correspondence
********************************************************

Synopsis
========

  * Function: target (Macaulay2Doc),

See also
========

  * Correspondence -- the class of all correspondences

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

  * target(Correspondence) -- the target of
    a correspondence

TautologicalLineBundle -- a symbol used internally as a key
***********************************************************

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

If $X$ is an abstract variety and its tautological line bundle has already been
built, it is stored in X.TautologicalLineBundle.  However, because building
this bundle can be computationally intensive, it is often not built unless it
is requested by tautologicalLineBundle.  The
programmer is warned not to make direct reference to this key for this reason.

+---------------------------------------------------------------+
|i1 : X = abstractProjectiveSpace 3                             |
|                                                               |
|o1 = X                                                         |
|                                                               |
|o1 : a flag bundle with subquotient ranks {1, 3}               |
+---------------------------------------------------------------+
|i2 : try X.TautologicalLineBundle else print "bundle not found"|
|bundle not found                                               |
+---------------------------------------------------------------+
|i3 : L = tautologicalLineBundle X                              |
|                                                               |
|o3 = L                                                         |
|                                                               |
|o3 : an abstract sheaf of rank 1 on X                          |
+---------------------------------------------------------------+
|i4 : L === X.TautologicalLineBundle                            |
|                                                               |
|o4 = true                                                      |
+---------------------------------------------------------------+
|i5 : rank L                                                    |
|                                                               |
|o5 = 1                                                         |
+---------------------------------------------------------------+
|i6 : chern L                                                   |
|                                                               |
|o6 = 1 + H                                                     |
|          2,1                                                  |
|                                                               |
|                       QQ[][h, H   ..H   ]                     |
|                                2,1   2,3                      |
|o6 : -------------------------------------------------------   |
|     (- h - H   , - h*H    - H   , - h*H    - H   , -h*H   )   |
|             2,1       2,1    2,2       2,2    2,3      2,3    |
+---------------------------------------------------------------+

Here are the preferred ways to get the tautological line bundle:

+-------------------------------------+
|i7 : OO_X(1)                         |
|                                     |
|o7 = L                               |
|                                     |
|o7 : an abstract sheaf of rank 1 on X|
+-------------------------------------+
|i8 : L === oo                        |
|                                     |
|o8 = true                            |
+-------------------------------------+
|i9 : tautologicalLineBundle X        |
|                                     |
|o9 = L                               |
|                                     |
|o9 : an abstract sheaf of rank 1 on X|
+-------------------------------------+
|i10 : L === oo                       |
|                                     |
|o10 = true                           |
+-------------------------------------+

See also
========

  * tautologicalLineBundle -- get the
    tautological line bundle of a flag bundle or abstract variety

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

The object TautologicalLineBundle, is a
symbol (Macaulay2Doc).

tautologicalLineBundle -- get the tautological line bundle of a flag bundle or abstract variety
***********************************************************************************************

Synopsis
========

  * Usage:
        tautologicalLineBundle X

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

Returns the tautological line bundle of the variety $X$.  In the case of a
FlagBundle, this is the line bundle defining the Pl\"ucker
embedding.

Used in AbstractSheaf ZZ.

See also
========

  * AbstractSheaf ZZ -- twist by a divisor
    class

Ways to use tautologicalLineBundle:
===================================

  * "tautologicalLineBundle(AbstractVariety)"
  * "tautologicalLineBundle(FlagBundle)"

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

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

todd -- compute the Todd class of an abstract sheaf, variety, map
*****************************************************************

Synopsis
========

  * Usage:
        todd F
        todd X
        todd f
  * Inputs:
      * F, an abstract sheaf,
      * X, an abstract variety,
      * f, an abstract variety map,
  * Outputs:
      * a ring element (Macaulay2Doc), the Todd class of
        $F$, of the (absolute) tangent bundle of $X$, of the (relative) tangent
        bundle of $f$

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

+-----------------------------------------------------------------------------+
|i1 : todd abstractProjectiveSpace 6                                          |
|                                                                             |
|         7       35       49       203       49                              |
|o1 = 1 + -H    + --H    + --H    + ---H    + --H    + H                      |
|         2 2,1    6 2,2    8 2,3    45 2,4   20 2,5    2,6                   |
|                                                                             |
|                                                 QQ[][h, H   ..H   ]         |
|                                                          2,1   2,6          |
|o1 : ------------------------------------------------------------------------|
|     (- h - H   , - h*H    - H   , - h*H    - H   , - h*H    - H   , - h*H   |
|             2,1       2,1    2,2       2,2    2,3       2,3    2,4       2,4|
|-----------------------------------------------------------------------------|
|----------------------------------                                           |
| - H   , - h*H    - H   , -h*H   )                                           |
|    2,5       2,5    2,6      2,6                                            |
+-----------------------------------------------------------------------------+

Ways to use todd:
=================

  * "todd(AbstractSheaf)"
  * "todd(AbstractVariety)"
  * "todd(AbstractVarietyMap)"

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

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

toSchubertBasis -- express cycles on a Grassmannian in terms of the Schubert basis
**********************************************************************************

Synopsis
========

  * Usage:
        toSchubertBasis c
  * Inputs:
      * c, a ring element (Macaulay2Doc), An element of the
        intersection ring of a Grassmannian of $k$-dimensional subspaces of a
        rank-$n$ vector bundle
  * Outputs:
      * An element $c'$ of a polynomial ring $B[s_\lambda]$ where $B$ is the
        base ring of G and $\lambda$ runs over all diagrams in a $k\times n$
        rectangle (this is the "Schubert ring" of G, see schubertRing).
        The element $c'$ is the representation of $c$ in terms
        of the Schubert basis of the intersection ring of G over B.

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

Note that the Schubert basis used here is in "Fulton-style" notation; see
schubertCycle.

+-------------------------------------------------------------------+
|i1 : A = flagBundle({3,3},VariableNames => H)                      |
|                                                                   |
|o1 = A                                                             |
|                                                                   |
|o1 : a flag bundle with subquotient ranks {2:3}                    |
+-------------------------------------------------------------------+
|i2 : S = first bundles A                                           |
|                                                                   |
|o2 = S                                                             |
|                                                                   |
|o2 : an abstract sheaf of rank 3 on A                              |
+-------------------------------------------------------------------+
|i3 : G = flagBundle({1,2},S,VariableNames => K)                    |
|                                                                   |
|o3 = G                                                             |
|                                                                   |
|o3 : a flag bundle with subquotient ranks {1..2}                   |
+-------------------------------------------------------------------+
|i4 : RG = intersectionRing G                                       |
|                                                                   |
|o4 = RG                                                            |
|                                                                   |
|o4 : QuotientRing                                                  |
+-------------------------------------------------------------------+
|i5 : c = H_(2,3)*((K_(2,1))^2) + H_(1,1)*K_(2,2)                   |
|                                                                   |
|                                              2                    |
|o5 = - H   K    + (H   K    - H   H   K    - H   H    + H   H   )  |
|        2,1 2,2     2,3 2,2    2,1 2,3 2,1    2,1 2,3    2,2 2,3   |
|                                                                   |
|o5 : RG                                                            |
+-------------------------------------------------------------------+
|i6 : toSchubertBasis c                                             |
|                                                                   |
|         2                                                         |
|o6 = (- H   H    + H   H   )s    - H   H   s    + (H    - H   )s   |
|         2,1 2,3    2,2 2,3  {0}    2,1 2,3 {1}     2,3    2,1  {2}|
|                                                                   |
|o6 : Schubert Basis of G(1,3) over A                               |
+-------------------------------------------------------------------+

See also
========

  * schubertRing -- get the Schubert ring of a
    Grassmannian

Ways to use toSchubertBasis:
============================

  * "toSchubertBasis(RingElement)"

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

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

transpose(Correspondence) -- reverse the direction of a correspondence
**********************************************************************

Synopsis
========

  * Function: transpose (Macaulay2Doc),
  * Usage:
        transpose I
  * Inputs:
      * I, an instance of the type Correspondence, from
        $X$ to $Y$
  * Outputs:
      * J, an instance of the type Correspondence, from
        $Y$ to $X$, such that $J_* = I^*$ and $J^* = I_*$.  In the case of an
        IncidenceCorrespondence, the
        intermediates, are also carried along appropriately,
        that is, if intermediates I is the tuple $(Z,f,g)$, then intermediates
        J is the tuple $(Z,g,f)$.

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

  * transpose(Correspondence) -- reverse
    the direction of a correspondence
  * "transpose(IncidenceCorrespondence)"

use(AbstractVariety) -- assign values to variables associated with a variety
****************************************************************************

Synopsis
========

  * Function: use (Macaulay2Doc),
  * Usage:
        use X
  * Inputs:
      * X,
  * Outputs:
      * an abstract variety, X
  * Consequences:
      * The generators of the intersection ring of X are assigned to their
        variables.  See use(Ring) (Macaulay2Doc).
      * The named bundles on X are assigned to their variables.

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

+---------------------------------------+
|i1 : S = base(n, Bundle => (E,3,c))    |
|                                       |
|o1 = S                                 |
|                                       |
|o1 : an abstract variety of dimension 0|
+---------------------------------------+
|i2 : E                                 |
|                                       |
|o2 = E                                 |
|                                       |
|o2 : an abstract sheaf of rank 3 on S  |
+---------------------------------------+
|i3 : n                                 |
|                                       |
|o3 = n                                 |
|                                       |
|o3 : QQ[n]                             |
+---------------------------------------+
|i4 : n = E = 4;                        |
+---------------------------------------+
|i5 : E                                 |
|                                       |
|o5 = 4                                 |
+---------------------------------------+
|i6 : n                                 |
|                                       |
|o6 = 4                                 |
+---------------------------------------+
|i7 : use S                             |
|                                       |
|o7 = S                                 |
|                                       |
|o7 : an abstract variety of dimension 0|
+---------------------------------------+
|i8 : E                                 |
|                                       |
|o8 = a sheaf                           |
|                                       |
|o8 : an abstract sheaf of rank 3 on S  |
+---------------------------------------+
|i9 : n                                 |
|                                       |
|o9 = n                                 |
|                                       |
|o9 : QQ[n]                             |
+---------------------------------------+

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

  * use(AbstractVariety) -- assign values to
    variables associated with a variety

value(ChernClassVariable) -- the value of a Chern class symbol
**************************************************************

Synopsis
========

  * Function: value (Macaulay2Doc),
  * Usage:
        value v
  * Inputs:
      * v,
  * Outputs:
      * The value of v.

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

+----------------------------+
|i1 : x = chern_3 E          |
|                            |
|o1 = c E                    |
|      3                     |
|                            |
|o1 : ChernClassVariable     |
+----------------------------+
|i2 : chern_3 E <- 444       |
|                            |
|o2 = 444                    |
+----------------------------+
|i3 : E                      |
|                            |
|o3 = E                      |
|                            |
|o3 : ChernClassVariableTable|
+----------------------------+
|i4 : x                      |
|                            |
|o4 = c E                    |
|      3                     |
|                            |
|o4 : ChernClassVariable     |
+----------------------------+
|i5 : value x                |
|                            |
|o5 = 444                    |
+----------------------------+

See also
========

  * ChernClassVariableTable -- the class of all
    Chern class variable tables

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

  * value(ChernClassVariable) -- the
    value of a Chern class symbol

variety(AbstractSheaf) -- the variety of an abstract sheaf
**********************************************************

Synopsis
========

  * Function: variety (Varieties),
  * Usage:
        variety F
  * Inputs:
      * F,
  * Outputs:
      * the variety of F

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

+------------------------------------------------+
|i1 : X = abstractProjectiveSpace 4              |
|                                                |
|o1 = X                                          |
|                                                |
|o1 : a flag bundle with subquotient ranks {1, 4}|
+------------------------------------------------+
|i2 : tangentBundle X                            |
|                                                |
|o2 = a sheaf                                    |
|                                                |
|o2 : an abstract sheaf of rank 4 on X           |
+------------------------------------------------+
|i3 : variety oo                                 |
|                                                |
|o3 = X                                          |
|                                                |
|o3 : a flag bundle with subquotient ranks {1, 4}|
+------------------------------------------------+

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

  * variety(AbstractSheaf) -- the variety of
    an abstract sheaf

VarietyDimension -- get the dimension of a variety from its intersection ring
*****************************************************************************

Synopsis
========

  * Usage:
        A.VarietyDimension
  * Inputs:
      * A, a ring (Macaulay2Doc), the intersection ring of an
        abstract variety

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

+------------------------------------------------+
|i1 : X = abstractProjectiveSpace 3              |
|                                                |
|o1 = X                                          |
|                                                |
|o1 : a flag bundle with subquotient ranks {1, 3}|
+------------------------------------------------+
|i2 : A =intersectionRing X                      |
|                                                |
|o2 = A                                          |
|                                                |
|o2 : QuotientRing                               |
+------------------------------------------------+
|i3 : A.VarietyDimension                         |
|                                                |
|o3 = 3                                          |
+------------------------------------------------+

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

The object VarietyDimension, is a symbol (Macaulay2Doc).