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

CotangentSchubert -- A package for cotangent Schubert calculus
**************************************************************

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

CotangentSchubert is a package for calculations in cotangent Schubert calculus.
Specifically, it allows to compute motivic Chern and Segre classes (as well as
their limits in ordinary Schubert calculus, namely Schubert classes), and to
independently compute the expansion of their products using puzzles. Puzzles
and their "fugacities" are defined and computed using the results of [1,2,3].

References:  [1] A. Knutson and P. Zinn-Justin, Schubert puzzles and
integrability I: invariant trilinear forms, arXiv:1706.10019 (see
http://arxiv.org/abs/1706.10019 ).  [2] A. Knutson and P. Zinn-Justin, Schubert
puzzles and integrability II: multiplying motivic Segre classes,
arXiv:2102.00563 (see http://arxiv.org/abs/2102.00563 ).  [3] A. Knutson and P.
Zinn-Justin, Schubert puzzles and integrability III: separated descents,
arXiv:2306.13855 (see http://arxiv.org/abs/2306.13855 ).

Author
======

  * Paul Zinn-Justin (see http://blogs.unimelb.edu.au/paul-zinn-justin/ )
    <pzinn@unimelb.edu.au>

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

Version 0.63 of this package was accepted for publication in volume 14 (see
https://msp.org/jsag/2024/14-1/ ) of Journal of Software for Algebra and
Geometry (see https://msp.org/jsag/ ) on 2024-02-06, in the article The
CotangentSchubert Macaulay2 package (see
https://msp.org/jsag/2024/14-1/p09.xhtml ) (DOI: 10.2140/jsag.2024.14.73 (see
https://doi.org/10.2140/jsag.2024.14.73 )). That version can be obtained from
the journal (see https://msp.org/jsag/2024/14-1/jsag-v14-n1-x09-
CotangentSchubert.m2 ).

Version
=======

This documentation describes version 0.71 of CotangentSchubert.

Citation
========

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

+----------------------------------------------------------------------------+
|@misc{CotangentSchubertSource,                                              |
|  title = {{CotangentSchubert: Cotangent Schubert calculus. Version~0.71}}, |
|  author = {Paul Zinn-Justin},                                              |
|  howpublished = {A \emph{Macaulay2} package available at                   |
|    \url{https://github.com/Macaulay2/M2/tree/master/M2/Macaulay2/packages}}|
|}                                                                           |
|                                                                            |
|@article{CotangentSchubertArticle,                                          |
|  title = {{The CotangentSchubert \emph{Macaulay2} package}},               |
|  author = {Paul Zinn-Justin},                                              |
|  journal = {Journal of Software for Algebra and Geometry},                 |
|  volume = {14},                                                            |
|  year = {2024},                                                            |
|}                                                                           |
|                                                                            |
+----------------------------------------------------------------------------+

Exports
=======

  * Types
      * LabelList (missing documentation)
      * "Puzzle" -- see puzzle, -- Compute puzzles with given
        boundaries
  * Functions and commands
      * basisCoeffs -- Expand a finite-dimensional algebra
        element into its basis
      * bottom -- The bottom string of a puzzle
      * canonicalClass -- Class of the canonical bundle
        of a flag variety
      * chernClass -- Compute a motivic Chern class
      * "chernClass'" -- see chernClass, -- Compute a motivic
        Chern class
      * "stableClass" -- see chernClass, -- Compute a motivic
        Chern class
      * "stableClass'" -- see chernClass, -- Compute a
        motivic Chern class
      * doublePuzzle -- Produces a rhombus puzzle
      * dualZeroSection -- Class of the zero section of
        the tangent bundle of a flag variety
      * fugacity -- compute the fugacity of puzzles
      * "fugacityTally" -- see fugacity, -- compute the
        fugacity of puzzles
      * "fugacityVector" -- see fugacity, -- compute the
        fugacity of puzzles
      * inversion -- Inversion number of a string
      * pushforwardToPoint -- Push forward classes
        to a point
      * "pushforwardToPointFromCotangent" -- see pushforwardToPoint,
        -- Push forward classes to a point
      * puzzle -- Compute puzzles with given boundaries
      * restrict -- Restriction to fixed points
      * schubertClass -- Compute a Schubert class
      * "schubertClass'" -- see schubertClass, -- Compute
        a Schubert class
      * "sClass" -- see segreClass, -- Compute a motivic
        Segre class
      * "sClass'" -- see segreClass, -- Compute a motivic
        Segre class
      * segreClass -- Compute a motivic Segre class
      * "segreClass'" -- see segreClass, -- Compute a motivic
        Segre class
      * setupCotangent -- Set up cotangent Schubert
        calculus rings
      * tautoClass -- Compute the class of a tautological
        bundle
      * zeroSection -- Class of the zero section of the
        cotangent bundle of a flag variety
  * Methods
      * inversion(LabelList) (missing documentation)
      * net(LabelList) (missing documentation)
      * new LabelList from List (missing documentation)
      * new LabelList from String (missing documentation)
      * new List from Puzzle (missing documentation)
      * Puzzle ++ HashTable (missing documentation)
      * Puzzle ++ List (missing documentation)
      * Puzzle == Puzzle (missing documentation)
      * texMath(LabelList) (missing documentation)
      * toExternalString(LabelList) (missing documentation)
      * toString(LabelList) (missing documentation)
  * Symbols
      * assoc (missing documentation)

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

The object CotangentSchubert, is a package (Macaulay2Doc),
defined in CotangentSchubert.m2, with auxiliary files
in CotangentSchubert/.

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

The source of this document is in CotangentSchubert.m2:398:0.

assoc
*****

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

The object assoc (missing documentation) is a symbol (Macaulay2Doc).

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

The source of this document is in
/home/runner/work/M2/M2/M2/BUILD/build/Macaulay2/packages/currentString:2:0.

basisCoeffs -- Expand a finite-dimensional algebra element into its basis
*************************************************************************

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

This is a simple helper function.

+-----------------------------------------------------------------------------+
|i1 : (A,B,FF,I)=setupCotangent(2,4,Presentation=>Borel,Ktheory=>true,        |
|                                                                             |
|o1 = (A, B, FF, {0 0 1 1, 0 1 0 1, 0 1 1 0, 1 0 0 1, 1 0 1 0, 1 1 0 0        |
|                                                                             |
|o1 : Sequence                                                                |
|-----------------------------------------------------------------------------|
|Equivariant=>false)                                                          |
|                                                                             |
|})                                                                           |
+-----------------------------------------------------------------------------+
|i2 : basis A                                                                 |
|                                                                             |
|o2 = | 1 x_(1,{3, 4}) x_(1,{3, 4})^2 x_(1,{3, 4})x_(2,{3, 4}) x_(2,{3, 4})   |
|     ------------------------------------------------------------------------|
|     x_(2,{3, 4})^2 |                                                        |
|                                                                             |
|             1      6                                                        |
|o2 : Matrix A  <-- A                                                         |
+-----------------------------------------------------------------------------+
|i3 : basisCoeffs(x_(1,{1,2})^2)                                              |
|                                                                             |
|o3 = | 16 |                                                                  |
|     | -8 |                                                                  |
|     | 1  |                                                                  |
|     | 0  |                                                                  |
|     | 0  |                                                                  |
|     | 0  |                                                                  |
|                                                                             |
|              6       1                                                      |
|o3 : Matrix FF  <-- FF                                                       |
+-----------------------------------------------------------------------------+

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

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

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

The source of this document is in CotangentSchubert.m2:398:0.

bottom -- The bottom string of a puzzle
***************************************

  * Usage:
        bottom P
  * Inputs:
      * P, an instance of the type Puzzle,

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

Reads off the bottom boundary string of a puzzle.

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

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

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

The source of this document is in CotangentSchubert.m2:398:0.

canonicalClass -- Class of the canonical bundle of a flag variety
*****************************************************************

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

This function returns the class of the canonical bundle of the flag variety in
the cohomology ring given as argument (or the last ring defined with
setupCotangent, if no argument is given).

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

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

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

The source of this document is in CotangentSchubert.m2:398:0.

chernClass -- Compute a motivic Chern class
*******************************************

  * Usage:
        chernClass i
        chernClass I
        chernClass(i,A)
        chernClass(I,A)
        chernClass' i
        stableClass i
        stableClass' i
  * Inputs:
      * i, a string (Macaulay2Doc),
      * I, a list (Macaulay2Doc),
      * A, a ring (Macaulay2Doc),

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

This function computes a motivic Chern class with label i (a string made of
characters from "0" to "d" where d is the number of steps of the flag variety)
or list of labels I in a K-theory ring A previously built using
setupCotangent. If A is not specified, then the ring that was
defined last is used.

+-----------------------------------------------------------------------------+
|i1 : (A,B,FF,I)=setupCotangent(1,3,Presentation=>Borel,Ktheory=>true,        |
|-----------------------------------------------------------------------------|
|Equivariant=>false);                                                         |
+-----------------------------------------------------------------------------+
|i2 : chernClass "101"                                                        |
|                                                                             |
|         2             2           2                                         |
|     - 2q  + 3        q  - 2      q  - 2       1                             |
|o2 = ---------*x x  + ------*x  + ------*x  + --                             |
|          2     2 3      2    2      2    3    2                             |
|         q              q           q         q                              |
|                                                                             |
|o2 : B                                                                       |
+-----------------------------------------------------------------------------+

If a list of labels I is used, then a matrix of classes is returned.

+-----------------------------------------------------------------------------+
|i3 : chernClass I                                                            |
|                                                                             |
|o3 = | (q4-6q2+6)/q4x_2x_3+(2q2-3)/q4x_2+(2q2-3)/q4x_3+1/q4                  |
|     ------------------------------------------------------------------------|
|     (-2q2+3)/q2x_2x_3+(q2-2)/q2x_2+(q2-2)/q2x_3+1/q2 x_2x_3-x_2-x_3+1 |     |
|                                                                             |
|             1      3                                                        |
|o3 : Matrix B  <-- B                                                         |
+-----------------------------------------------------------------------------+

stableClass differs from chernClass by division by the canonical class of the
flag variety. The primed classes are dual classes.

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

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

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

The source of this document is in CotangentSchubert.m2:398:0.

doublePuzzle -- Produces a rhombus puzzle
*****************************************

  * Usage:
        doublePuzzle (a,b,c,d)
  * Inputs:
      * a, a string (Macaulay2Doc),
      * b, a string (Macaulay2Doc),
      * c, a string (Macaulay2Doc),
      * d, a string (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Equivariant (missing documentation) => ..., default value true,
      * Generic (missing documentation) => ..., default value true,
      * Ktheory (missing documentation) => ..., default value false,
      * Ktheory' (missing documentation) => ..., default value false,
      * Separation (missing documentation) => ..., default value null,
      * Steps (missing documentation) => ..., default value null,

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

Given 4 strings, computes the number of pairs of puzzles glued together to form
a rhombus with boundaries a,b,c,d in clockwise order.

In WebApp mode, the output is interactive and allows to test associativity of
puzzles.

+-----------------------------------------------------------------------------+
|i1 : doublePuzzle("0101","0101","0101","0101",Equivariant=>false)            |
|                                                                             |
|o1 = {                   /\                   ,                              |
|                        /  \                                                 |
|                       1    0                                                |
|                      /      \                                               |
|                      ---10---                                               |
|                    /\        /\                                             |
|                   /  \      /  \                                            |
|                  0    0    1    1                                           |
|                 /      \  /      \                                          |
|                 ---0----  ---1----                                          |
|               /\        /\        /\                                        |
|              /  \      /  \      /  \                                       |
|             1    1    10   1    1    0                                      |
|            /      \  /      \  /      \                                     |
|            ---1----  ---0----  ---10---                                     |
|          /\        /\        /\        /\                                   |
|         /  \      /  \      /  \      /  \                                  |
|        0   10    0    0    0    0    1    1                                 |
|       /      \  /      \  /      \  /      \                                |
|       ---1----  ---0----  ---0----  ---1----                                |
|       \      /  \      /  \      /  \      /                                |
|        1    1    0    0    0    0    10   0                                 |
|         \  /      \  /      \  /      \  /                                  |
|          \/        \/        \/        \/                                   |
|            ---10---  ---0----  ---1----                                     |
|            \      /  \      /  \      /                                     |
|             0    1    1   10    1    1                                      |
|              \  /      \  /      \  /                                       |
|               \/        \/        \/                                        |
|                 ---1----  ---0----                                          |
|                 \      /  \      /                                          |
|                  1    1    0    0                                           |
|                   \  /      \  /                                            |
|                    \/        \/                                             |
|                      ---10---                                               |
|                      \      /                                               |
|                       0    1                                                |
|                        \  /                                                 |
|                         \/                                                  |
|     ------------------------------------------------------------------------|
|                       /\                   }                                |
|                      /  \                                                   |
|                     1    0                                                  |
|                    /      \                                                 |
|                    ---10---                                                 |
|                  /\        /\                                               |
|                 /  \      /  \                                              |
|                0    0    1    1                                             |
|               /      \  /      \                                            |
|               ---0----  ---1----                                            |
|             /\        /\        /\                                          |
|            /  \      /  \      /  \                                         |
|           1    0    0   10    0    0                                        |
|          /      \  /      \  /      \                                       |
|          ---10---  ---1----  ---0----                                       |
|        /\        /\        /\        /\                                     |
|       /  \      /  \      /  \      /  \                                    |
|      0    0    1    1    1    1    10   1                                   |
|     /      \  /      \  /      \  /      \                                  |
|     ---0----  ---1----  ---1----  ---0----                                  |
|     \      /  \      /  \      /  \      /                                  |
|      1   10    1    1    1    1    0    0                                   |
|       \  /      \  /      \  /      \  /                                    |
|        \/        \/        \/        \/                                     |
|          ---0----  ---1----  ---10---                                       |
|          \      /  \      /  \      /                                       |
|           0    0    10   0    0    1                                        |
|            \  /      \  /      \  /                                         |
|             \/        \/        \/                                          |
|               ---1----  ---0----                                            |
|               \      /  \      /                                            |
|                1    1    0    0                                             |
|                 \  /      \  /                                              |
|                  \/        \/                                               |
|                    ---10---                                                 |
|                    \      /                                                 |
|                     0    1                                                  |
|                      \  /                                                   |
|                       \/                                                    |
|                                                                             |
|o1 : List                                                                    |
+-----------------------------------------------------------------------------+

Caveat
======

At the moment, the interactive part only works on nonequivariant puzzles.

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

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

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

The source of this document is in CotangentSchubert.m2:398:0.

dualZeroSection -- Class of the zero section of the tangent bundle of a flag variety
************************************************************************************

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

This function returns the class of the base of the tangent bundle of the flag
variety in the cohomology ring given as argument (or the last ring defined with
setupCotangent, if no argument is given).

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

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

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

The source of this document is in CotangentSchubert.m2:398:0.

fugacity -- compute the fugacity of puzzles
*******************************************

  * Usage:
        fugacity P
        fugacityVector L
        fugacityTally L
  * Inputs:
      * P, an instance of the type Puzzle,
      * L, a list (Macaulay2Doc), a list of puzzles

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

To each puzzle is associated an element of the base field (cohomology/K-theory
of a point), its so-called fugacity, in such a way that the sum of fugacities
of puzzles with prescribed boundaries a, b, c, is equal to the coefficient of
the expansion of the product of classes indexed by the strings a and b into the
class class indexed by the string c. Here the classes are motivic Segre classes
sClass, if Generic=>true, Schubert classes
schubertClass, if Generic=>false. The options Ktheory,
Equivariant, Generic are inherited from the puzzle, by default,
but they can be overridden.

fugacityTally processes a list of puzzles, and returns a hash table where to
each string appearing at the bottom of a puzzle is associated the sum of
fugacities of the corresponding puzzles.

fugacityVextor similarly processes a list of puzzles, and returns the result as
a vector where each entry is the sum of fugacities of puzzles with a given
bottom string. The ordering of strings is the same as the list returned by
setupCotangent.

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

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

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

The source of this document is in CotangentSchubert.m2:398:0.

inversion -- Inversion number of a string
*****************************************

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

Given a string of digits "a_1 a_2 ... a_n", computes the inversion number of
that string (the number of i<j such that a_i>a_j).

Ways to use inversion:
======================

  * inversion(LabelList) (missing documentation)

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

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

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

The source of this document is in CotangentSchubert.m2:398:0.

LabelList
*********

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

  * inversion(LabelList) (missing documentation)
  * net(LabelList) (missing documentation)
  * new LabelList from List (missing documentation)
  * new LabelList from String (missing documentation)
  * texMath(LabelList) (missing documentation)
  * toExternalString(LabelList) (missing documentation)
  * toString(LabelList) (missing documentation)

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

The object LabelList (missing documentation) is a type (Macaulay2Doc),
with ancestor classes List (Macaulay2Doc), <
VisibleList (Macaulay2Doc) < BasicList (Macaulay2Doc)
< Thing (Macaulay2Doc).

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

The source of this document is in
/home/runner/work/M2/M2/M2/BUILD/build/Macaulay2/packages/currentString:2:0.

pushforwardToPoint -- Push forward classes to a point
*****************************************************

  * Usage:
        pushforwardToPoint a
        pushforwardToPointFromCotangent a
  * Inputs:
      * a, a ring element (Macaulay2Doc),

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

This function returns the push forward of a (K-theory or cohomology) class from
either the flag variety or its cotangent bundle to a point. The ring of input a
must have been previously created with setupCotangent.

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

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

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

The source of this document is in CotangentSchubert.m2:398:0.

puzzle -- Compute puzzles with given boundaries
***********************************************

  * Usage:
        puzzle (a,b)
        puzzle (a,b,c)
  * Inputs:
      * a, a string (Macaulay2Doc),
      * b, a string (Macaulay2Doc),
      * c, a string (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Ktheory => a Boolean value (Macaulay2Doc), default value
        false
      * Equivariant => a Boolean value (Macaulay2Doc), default
        value true
      * Generic => a Boolean value (Macaulay2Doc), default value
        true
      * Ktheory' => a Boolean value (Macaulay2Doc), default
        value false, has an effect only if Generic => false
      * Labels => a Boolean value (Macaulay2Doc), default value
        true
      * Paths => a Boolean value (Macaulay2Doc), default value
        false
      * Steps => an integer (Macaulay2Doc), default value null
      * Separation (missing documentation) => ..., default value null,

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

This function produces a list of puzzles with boundaries given by strings a
(northwest side), b (northeast side), c (bottom side). The default
Generic=>true produces "generic" puzzles corresponding to the multiplication of
motivic Segre classes sClass, whereas Generic=>false
produces "classic" puzzles corresponding to the multiplication of Schubert
classes schubertClass, (in the latter case, Ktheory'=>true
produces puzzles for dual Schubert classes).

The boundaries are encoded as strings of digits from "0" to "d", where d is the
number of steps of the flag variety; alternatively, one can use lists of
integers or strings (the latter allows for the possibility of having arbitrary
puzzle labels on the boundary, such as "2(10)", even though this will not occur
in normal puzzle computations). The special symbol "#" stands for any single
digit, whereas "*" stands for any puzzle label.

Labels and Paths are drawing options which only affect HTML and TeX output of
puzzles.

+-----------------------------------------------------------------------------+
|i1 : puzzle ("0101","1001",Equivariant=>false)                               |
|                                                                             |
|o1 = {                   /\                   ,                              |
|                        /  \                                                 |
|                       1    1                                                |
|                      /      \                                               |
|                      ---1----                                               |
|                    /\        /\                                             |
|                   /  \      /  \                                            |
|                  0   10    0    0                                           |
|                 /      \  /      \                                          |
|                 ---1----  ---0----                                          |
|               /\        /\        /\                                        |
|              /  \      /  \      /  \                                       |
|             1    1    1    0    0    0                                      |
|            /      \  /      \  /      \                                     |
|            ---1----  ---10---  ---0----                                     |
|          /\        /\        /\        /\                                   |
|         /  \      /  \      /  \      /  \                                  |
|        0   10    0    0    1    1    10   1                                 |
|       /      \  /      \  /      \  /      \                                |
|       ---1----  ---0----  ---1----  ---0----                                |
|     ------------------------------------------------------------------------|
|                       /\                   }                                |
|                      /  \                                                   |
|                     1    1                                                  |
|                    /      \                                                 |
|                    ---1----                                                 |
|                  /\        /\                                               |
|                 /  \      /  \                                              |
|                0   10    0    0                                             |
|               /      \  /      \                                            |
|               ---1----  ---0----                                            |
|             /\        /\        /\                                          |
|            /  \      /  \      /  \                                         |
|           1    1    1    0    0    0                                        |
|          /      \  /      \  /      \                                       |
|          ---1----  ---10---  ---0----                                       |
|        /\        /\        /\        /\                                     |
|       /  \      /  \      /  \      /  \                                    |
|      0   10    0   10    10   1    10   1                                   |
|     /      \  /      \  /      \  /      \                                  |
|     ---1----  ---1----  ---0----  ---0----                                  |
|                                                                             |
|o1 : List                                                                    |
+-----------------------------------------------------------------------------+

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

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

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

The source of this document is in CotangentSchubert.m2:398:0.

restrict -- Restriction to fixed points
***************************************

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

Given a (K-theory or cohomology) class in a ring defined by
setupCotangent, with the options Presentation => Borel and
Equivariance => true, this function computes its restriction to fixed points
(effectively, giving the class as would be produced by the option Presentation
=> EquivLoc).

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

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

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

The source of this document is in CotangentSchubert.m2:398:0.

schubertClass -- Compute a Schubert class
*****************************************

  * Usage:
        schubertClass i
        schubertClass I
        schubertClass(i,A)
        schubertClass(I,A)
        schubertClass' i
  * Inputs:
      * i, a string (Macaulay2Doc),
      * I, a list (Macaulay2Doc),
      * A, a ring (Macaulay2Doc),

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

This function computes a Schubert class with label i (a string made of
characters from "0" to "d" where d is the number of steps of the flag variety)
or list of labels I in a K-theory ring A previously built using
setupCotangent. If A is not specified, then the ring that was
defined last is used. The primed classes are dual classes.

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

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

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

The source of this document is in CotangentSchubert.m2:398:0.

segreClass -- Compute a motivic Segre class
*******************************************

  * Usage:
        segreClass i
        segreClass I
        segreClass(i,A)
        segreClass(I,A)
        segreClass' i
        sClass i
        sClass' i
  * Inputs:
      * i, a string (Macaulay2Doc),
      * I, a list (Macaulay2Doc),
      * A, a ring (Macaulay2Doc),

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

This function computes a motivic Segre class with label i (a string made of
characters from "0" to "d" where d is the number of steps of the flag variety)
or list of labels I in a K-theory ring A previously built using
setupCotangent. If A is not specified, then the ring that was
defined last is used.

+-----------------------------------------------------------------------------+
|i1 : (A,B,FF,I)=setupCotangent(1,3,Presentation=>Borel,Ktheory=>true,        |
|-----------------------------------------------------------------------------|
|Equivariant=>false);                                                         |
+-----------------------------------------------------------------------------+
|i2 : segreClass "101"                                                        |
|                                                                             |
|            4                4    2            4    2               2        |
|         -2q                q  + q            q  + q             -2q         |
|o2 = ------------*x x  + ------------*x  + ------------*x  + ------------    |
|      4     2      2 3    4     2      2    4     2      3    4     2        |
|     q  - 2q  + 1        q  - 2q  + 1      q  - 2q  + 1      q  - 2q  + 1    |
|                                                                             |
|o2 : B                                                                       |
+-----------------------------------------------------------------------------+

If a list of labels I is used, then a matrix of classes is returned.

+-----------------------------------------------------------------------------+
|i3 : segreClass I                                                            |
|                                                                             |
|o3 = | q4/(q4-2q2+1)x_2x_3+(-q2)/(q4-2q2+1)x_2+(-q2)/(q4-2q2+1)x_3+1/(q4-2q2+|
|     ------------------------------------------------------------------------|
|     1) (-2q4)/(q4-2q2+1)x_2x_3+(q4+q2)/(q4-2q2+1)x_2+(q4+q2)/(q4-2q2+1)x_3  |
|     ------------------------------------------------------------------------|
|     +(-2q2)/(q4-2q2+1) q4/(q4-2q2+1)x_2x_3+(-q4)/(q4-2q2+1)x_2+(-q4)/(q4-2q2|
|     ------------------------------------------------------------------------|
|     +1)x_3+q4/(q4-2q2+1) |                                                  |
|                                                                             |
|             1      3                                                        |
|o3 : Matrix B  <-- B                                                         |
+-----------------------------------------------------------------------------+

sClass differs from segreClass by multiplication by a power of the equivariant
parameter $q$. The primed classes are dual classes.

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

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

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

The source of this document is in CotangentSchubert.m2:398:0.

setupCotangent -- Set up cotangent Schubert calculus rings
**********************************************************

  * Usage:
        (A,B,FF,I) = setupCotangent(dimensions,Presentation=>Borel)
        (D,FF,I) = setupCotangent(dimensions,Presentation=>EquivLoc)
  * Inputs:
      * dimensions, a sequence (Macaulay2Doc), of integers
  * Optional inputs (Macaulay2Doc),:
      * Presentation => a symbol (Macaulay2Doc), default value
        EquivLoc
      * Ktheory => a Boolean value (Macaulay2Doc), default value
        false
      * Equivariant => a Boolean value (Macaulay2Doc), default
        value true

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

This function sets up the various rings used by CotangentSchubert. Its
behaviour depends on the value of the option Presentation.

With Presentation => Borel, setupCotangent returns a sequence made of two
rings, a field and a list:

+---------------------------------------------------------+
|i1 : (A,B,FF,I) = setupCotangent(1,3,Presentation=>Borel)|
|                                                         |
|o1 = (A, B, FF, {0 1 1, 1 0 1, 1 1 0})                   |
|                                                         |
|o1 : Sequence                                            |
+---------------------------------------------------------+

The first (resp. second) ring is the cohomology or K-theory ring of the
cotangent bundle of the flag variety specifided by the sequence of dimensions
of flags (resp. of the corresponding full flag variety). The field is the base
field (fraction field of the cohomology or K-theory ring of a point). The list
is a list of labels for the various classes that CotangentSchubert computes.
The boolean option Ktheory specifies the choice of K-theory or cohomology,
whereas Equivariant specifies whether the equivariance is w.r.t. scaling of the
fiber of the cotangent bundle only, or w.r.t. scaling and Cartan torus action.

With Presentation => EquivLoc:

+----------------------------------------------------------+
|i2 : (D,FF,I) = setupCotangent(1,3,Presentation=>EquivLoc)|
|                                                          |
|o2 = (D, FF, {0 1 1, 1 0 1, 1 1 0})                       |
|                                                          |
|o2 : Sequence                                             |
+----------------------------------------------------------+

the first output is a "diagonal algebra", i.e., a vector space over FF with
componentwise product. The last two outputs are the same as above.

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

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

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

The source of this document is in CotangentSchubert.m2:398:0.

tautoClass -- Compute the class of a tautological bundle
********************************************************

  * Usage:
        tautoClass (i,j)
        tautoClass (i,j,A)
  * Inputs:
      * i, an integer (Macaulay2Doc),
      * j, an integer (Macaulay2Doc),
      * A, a ring (Macaulay2Doc),

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

This function computes the i-th Chern class of the j-th tautological bundle of
the flag variety whose K-theory (or cohomology) ring is given by A. If A is not
specified, then the ring that was defined last is used.

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

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

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

The source of this document is in CotangentSchubert.m2:398:0.

zeroSection -- Class of the zero section of the cotangent bundle of a flag variety
**********************************************************************************

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

This function returns the class of the base of the cotangent bundle of the flag
variety in the cohomology ring given as argument (or the last ring defined with
setupCotangent, if no argument is given).

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

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

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

The source of this document is in CotangentSchubert.m2:398:0.