This is NumericalSchubertCalculus.info, produced by Macaulay2, version 1.21

NumericalSchubertCalculus -- Numerical Algorithms for Schubert Calculus
***********************************************************************

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

This package provides implementations of both the Littlewood-Richardson and
Pieri homotopy algorithms for solving (instances of) Schubert problems on
Grassmannians using numerical homotopy continuation.

A Schubert problem on the Grassmannian $Gr(k,n)$ is a list of Schubert
subvarieties (assumed general) of $Gr(k,n)$ whose codimensions add up to
$k(n-k)$, the dimension of the Grassmannian. A Schubert variety is represented
by a pair $(c,F)$, where $c$ is a Schubert condition (represented as a
partition or a bracket) and $F$ is a flag, represented as an invertible
$n\times n$-matrix. The Schubert variety for the pair $(c,F)$ consists of all
$k$-planes that satisfy the incidence condition $c$ imposed by the flag $F$.

For a Schubert problem, we may fix one flag for each Schubert condition in the
list --- i.e., describe an instance of a given Schubert problem --- and look
for the solutions for this instance --- i.e., points in the intersection of the
corresponding Schubert varieties. The methods of this package find
approximations of these points.

General functions:
------------------

  * randomSchubertProblemInstance, --
    returns a random instance of a given Schubert problem
  * changeFlags -- continue solutions of a Schubert problem
    to another instance
  * checkIncidenceSolution -- check if a
    solution satisfies an instance of a Schubert problem
  * LRnumber -- returns the number of solutions to the given
    Schubert problem

Functions implementing homotopies specific to Schubert calculus:
----------------------------------------------------------------

  * solveSchubertProblem -- uses
    Littlewood-Richardson homotopy algorithm to solve a Schubert problem
  * solveSimpleSchubert -- uses Pieri homotopy
    algorithm to solve a simple Schubert problem

Service functions:
------------------

  * setVerboseLevel -- set different levels of
    information printed on screen
  * bracket2partition -- dictionary between different
    notations for Schubert conditions.
  * partition2bracket -- dictionary between different
    notations for Schubert conditions.
  * NSC2phc -- dictionary between different notations for
    Schubert problems.

Using PHCpack:
--------------

An alternative implementation using PHCpack (download from here (see
http://homepages.math.uic.edu/~jan/download.html )) includes the following
functions:
  * LRrule -- computes the product of Schubert classes using
    geometric Littlewood-Richardson rule
  * LRtriple -- uses Littlewood-Richardson homotopy algorithm
    to solve a Schubert problem
  * parseTriplet -- Parses the output from LRtriple into
    Macaulay2 objects.
  * LRcheater -- A cheater's homotopy to a real Schubert
    triple intersection problem
  * PieriRootCount -- the number of solutions to a
    generic Pieri problem
  * PieriHomotopies -- runs the Pieri homotopies to
    solve a general hypersurface problem
Note that LRcheater, is similar to changeFlags,

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

For example, the Schubert problem {2,1}$^3$ in $Gr(3,6)$ with respect to random
flags has 2 solutions
+-----------------------------------------------------------------------------+
|i1 : k = 3; n = 6;                                                           |
+-----------------------------------------------------------------------------+
|i3 : SchPblm = {                                                             |
|         ({2,1}, random(CC^6,CC^6)),                                         |
|         ({2,1}, random(CC^6,CC^6)),                                         |
|         ({2,1}, random(CC^6,CC^6))                                          |
|         };                                                                  |
+-----------------------------------------------------------------------------+
|i4 : solveSchubertProblem(SchPblm, k,n)                                      |
|                                                                             |
|o4 = {| -.973546-.443329ii  -.193482-.957391ii -.460977-.267623ii  |, |      |
|      | .153343-.291038ii   .339479-1.30008ii  -.577303-.171329ii  |  |      |
|      | .326239-.770744ii   .120186-1.46205ii  -.0769985-.323186ii |  |      |
|      | -.451322-.514227ii  -.144874-.987789ii -.589493-.209825ii  |  |      |
|      | -.0525679-.692383ii .364061-.704785ii  -.325325-.185011ii  |  |      |
|      | -.942864-.594173ii  -.826353-.203654ii -.236865+.691374ii  |  |      |
|     ------------------------------------------------------------------------|
|     -5.47422+1.18674ii -.912706-1.64344ii -.590144+.126046ii |}             |
|     -2.80395-.714508ii -.793467-2.20255ii -.016225+.340982ii |              |
|     -2.29873-2.34724ii -.905617-2.59114ii .0951404+.355536ii |              |
|     -3.36313+2.14592ii -.703202-1.58202ii -.375349+.205204ii |              |
|     -3.91243-.845457ii -.528411-.900447ii -.187047+.545512ii |              |
|     -4.19554+1.93172ii -1.11528-.480829ii .19859+1.24706ii   |              |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+

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

References:

  * Vakil, "A geometric Littlewood-Richardson rule",Vakil, Ravi. A geometric
    Littlewood-Richardson rule. Ann. of Math. (2) 164 (2006), 371-421 (see
    https://arxiv.org/abs/math/0302294 )
  * Huber, Sottile, Sturmfels, "Numerical Schubert calculus",  J. Symb. Comp.,
    26 (1998), 767-788. (see https://arxiv.org/abs/alg-geom/9706004 )
  * Sottile, Vakil, Verschelde, "Solving Schubert Problems with
    Littlewood-Richardson Homotopies", ISSAC 2010, 179-186, ACM, New York,
    2010. (see https://arxiv.org/abs/1001.4125 )
  * Leykin and Sottile, "Galois groups of Schubert problems via homotopy
    computation",  Math. Comp. 78 (2009), 1749-1765. (see
    https://arxiv.org/abs/0710.4607 )
  * Leykin, Martin del Campo, Sottile, Vakil, Verschelde "Numerical Schubert
    Calculus via the Littlewood-Richardson homotopy algorithm", Math. Comp., 90
    (2021), 1407-1433.  (see https://arxiv.org/abs/1802.00984 )

Authors
=======

  * Anton Leykin (see http://people.math.gatech.edu/~aleykin3 )
    <leykin@math.gatech.edu>
  * Abraham Martin del Campo (see http://www.cimat.mx/~abraham.mc )
    <abraham.mc@cimat.mx>
  * Frank Sottile (see http://www.math.tamu.edu/~sottile )
    <sottile@math.tamu.edu>
  * Ravi Vakil (see http://math.stanford.edu/~vakil ) <vakil@math.stanford.edu>
  * Jan Verschelde (see http://www.math.uic.edu/~jan/ ) <jan@math.uic.edu>

Version
=======

This documentation describes version 1.17 of NumericalSchubertCalculus.

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

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

Exports
=======

  * Functions and commands
      * bracket2partition -- dictionary between
        different notations for Schubert conditions.
      * changeFlags -- continue solutions of a Schubert
        problem to another instance
      * checkIncidenceSolution -- check if a
        solution satisfies an instance of a Schubert problem
      * LRcheater -- A cheater's homotopy to a real Schubert
        triple intersection problem
      * LRnumber -- returns the number of solutions to the
        given Schubert problem
      * LRrule -- computes the product of Schubert classes using
        geometric Littlewood-Richardson rule
      * LRtriple -- uses Littlewood-Richardson homotopy
        algorithm to solve a Schubert problem
      * NSC2phc -- dictionary between different notations for
        Schubert problems.
      * parseTriplet -- Parses the output from LRtriple
        into Macaulay2 objects.
      * partition2bracket -- dictionary between
        different notations for Schubert conditions.
      * PieriHomotopies -- runs the Pieri homotopies to
        solve a general hypersurface problem
      * PieriRootCount -- the number of solutions to a
        generic Pieri problem
      * printStatistics -- summary statistics (used by
        developers)
      * "resetStatistics" -- see printStatistics, --
        summary statistics (used by developers)
      * randomSchubertProblemInstance, --
        returns a random instance of a given Schubert problem
      * setVerboseLevel -- set different levels of
        information printed on screen
      * solutionsToAffineCoords -- writes
        solutions in global coords to affine coordinates.
      * solveSchubertProblem -- uses
        Littlewood-Richardson homotopy algorithm to solve a Schubert problem
      * solveSimpleSchubert -- uses Pieri homotopy
        algorithm to solve a simple Schubert problem
      * wrapTriplet -- Wraps a flag, system, and solutions
        into one string for phc -e.
  * Methods
      * "bracket2partition(List,ZZ)" -- see bracket2partition,
        -- dictionary between different notations for
        Schubert conditions.
      * "changeFlags(List,Sequence)" -- see changeFlags, --
        continue solutions of a Schubert problem to another instance
      * changeFlags(Matrix,List,Sequence)
        -- recursive call of change
        flags
      * "checkIncidenceSolution(Matrix,List)" -- see
        checkIncidenceSolution, -- check if a solution
        satisfies an instance of a Schubert problem
      * "LRcheater(ZZ,Matrix,String)" -- see LRcheater, -- A
        cheater's homotopy to a real Schubert triple intersection problem
      * "LRnumber(List,ZZ,ZZ)" -- see LRnumber, -- returns the
        number of solutions to the given Schubert problem
      * "LRrule(ZZ,Matrix)" -- see LRrule, -- computes the
        product of Schubert classes using geometric Littlewood-Richardson rule
      * "LRtriple(ZZ,Matrix)" -- see LRtriple, -- uses
        Littlewood-Richardson homotopy algorithm to solve a Schubert problem
      * "NSC2phc(List,ZZ,ZZ)" -- see NSC2phc, -- dictionary
        between different notations for Schubert problems.
      * "parseTriplet(String,String,String)" -- see parseTriplet,
        -- Parses the output from LRtriple into Macaulay2
        objects.
      * "partition2bracket(List,ZZ,ZZ)" -- see partition2bracket,
        -- dictionary between different notations for
        Schubert conditions.
      * "PieriHomotopies(ZZ,ZZ)" -- see PieriHomotopies,
        -- runs the Pieri homotopies to solve a general hypersurface problem
      * "PieriRootCount(ZZ,ZZ,ZZ)" -- see PieriRootCount,
        -- the number of solutions to a generic Pieri problem
      * "randomSchubertProblemInstance(List,ZZ,ZZ)" -- see
        randomSchubertProblemInstance, --
        returns a random instance of a given Schubert problem
      * "setVerboseLevel(ZZ)" -- see setVerboseLevel, --
        set different levels of information printed on screen
      * "solutionsToAffineCoords(List)" -- see solutionsToAffineCoords,
        -- writes solutions in global coords to affine
        coordinates.
      * "solveSchubertProblem(List,ZZ,ZZ)" -- see solveSchubertProblem,
        -- uses Littlewood-Richardson homotopy algorithm
        to solve a Schubert problem
      * "solveSimpleSchubert(List,ZZ,ZZ)" -- see solveSimpleSchubert,
        -- uses Pieri homotopy algorithm to solve a simple
        Schubert problem
      * "wrapTriplet(String,String,String)" -- see wrapTriplet,
        -- Wraps a flag, system, and solutions into one string for
        phc -e.
  * Symbols
      * OneHomotopy -- strategy for changing flags.
      * RandomSeed -- seed for the random number generators.
      * WorkingPrecision -- option to raise the
        working precision to double double or quad double.

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

The object NumericalSchubertCalculus, is a package (Macaulay2Doc).

bracket2partition -- dictionary between different notations for Schubert conditions.
************************************************************************************

Synopsis
========

  * Usage:
        l = bracket2partition(b,n)
  * Inputs:
      * b, a list (Macaulay2Doc), of length $k$, a bracket
        representing a Schubert condition.
      * n, an integer (Macaulay2Doc), $k$ and $n$ represent the
        Grassmannian $Gr(k,n)$
  * Outputs:
      * l, a list (Macaulay2Doc), the corresponding partition

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

A Schubert condition in the Grassmannian $Gr(k,n)$ is encoded either by a
partition $l$ or by a bracket $b$.

A partition is a weakly decreasing list of at most $k$ nonnegative integers
less than or equal to $n-k$.  It may be padded with zeroes to be of length $k$.

A bracket is a strictly increasing list of length $k$ of positive integers
between $1$ and $n$.

This function writes a bracket as a partition. They are related as follows
$b_{k+1-i}=n-i-l_i$, for $i=1,...,k$.

+---------------------------+
|i1 : b = {1,3};            |
+---------------------------+
|i2 : n = 4;                |
+---------------------------+
|i3 : bracket2partition(b,n)|
|                           |
|o3 = {2, 1}                |
|                           |
|o3 : List                  |
+---------------------------+
|i4 : n = 6;                |
+---------------------------+
|i5 : bracket2partition(b,n)|
|                           |
|o5 = {4, 3}                |
|                           |
|o5 : List                  |
+---------------------------+
|i6 : b = {2,4,6};          |
+---------------------------+
|i7 : bracket2partition(b,n)|
|                           |
|o7 = {2, 1, 0}             |
|                           |
|o7 : List                  |
+---------------------------+

See also
========

  * partition2bracket -- dictionary between different
    notations for Schubert conditions.

Ways to use bracket2partition :
===============================

  * "bracket2partition(List,ZZ)"

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

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

changeFlags -- continue solutions of a Schubert problem to another instance
***************************************************************************

Synopsis
========

  * Usage:
        changeFlags(sols,CFG)
  * Inputs:
      * sols, a list (Macaulay2Doc), solutions of a Schubert
        problem written as $n\times k$ matrices
      * CFG, a sequence (Macaulay2Doc), a triple (C,F,G) where
        C is a list of m Schubert conditions, F is a list of m flags defining
        an instance with solution set sols, G is a list of m flags defining the
        instance whose solutions we want.
  * Optional inputs (Macaulay2Doc),:
      * OneHomotopy,
        => ..., default value true, strategy for moving solutions to a Schubert
        problem
  * Outputs:
      * a list (Macaulay2Doc), solutions of the problem with
        respect to flags G.

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

If sols is a set of solutions to a Schubert problem $l_1,\ldots,l_m$ with
respect to a set of flags $F_1,\ldots, F_m$, uses parameter homotopies to move
$S$ to a solution set $S'$ for the same Schubert problem, but with respect to
another set of flags $G_1,\ldots, G_m$.

For instance, consider the Schubert problem $(2,1)^3$ in $Gr(3,6)$.

+--------------+
|i1 : k=3; n=6;|
+--------------+
|i3 : l1={2,1};|
+--------------+
|i4 : l2={2,1};|
+--------------+
|i5 : l3={2,1};|
+--------------+

Generate flags $F$: standard flag, opposite flag, and one random.

+-----------------------------------------------------------------------------+
|i6 : F = {(l1, id_(CC^n)), (l2, rsort id_(CC^n)), (l3,random(CC^n,CC^n))}    |
|                                                                             |
|o6 = {({2, 1}, | 1 0 0 0 0 0 |), ({2, 1}, | 0 0 0 0 0 1 |), ({2, 1}, |       |
|               | 0 1 0 0 0 0 |            | 0 0 0 0 1 0 |            |       |
|               | 0 0 1 0 0 0 |            | 0 0 0 1 0 0 |            |       |
|               | 0 0 0 1 0 0 |            | 0 0 1 0 0 0 |            |       |
|               | 0 0 0 0 1 0 |            | 0 1 0 0 0 0 |            |       |
|               | 0 0 0 0 0 1 |            | 1 0 0 0 0 0 |            |       |
|     ------------------------------------------------------------------------|
|     .892712+.673395ii  .0741835+.808694ii .830833+.538554ii                 |
|     .29398+.632944ii   .362835+.706096ii  .873665+.415912ii                 |
|     .0258884+.714827ii .127435+.254482ii  .606588+.848005ii                 |
|     .89189+.231053ii   .741046+.108386ii  .191734+.403215ii                 |
|     .461944+.775187ii  .348931+.562428ii  .615911+.0147867ii                |
|     .909047+.314897ii  .246268+.153346ii  .223028+.388829ii                 |
|     ------------------------------------------------------------------------|
|     .557119+.873708ii .0647412+.877846ii .444183+.644366ii |)}              |
|     .7037+.681869ii   .0340514+.507989ii .194945+.518585ii |                |
|     .276259+.605659ii .150294+.656391ii  .987173+.568273ii |                |
|     .96518+.681683ii  .174853+.626892ii  .184779+.370833ii |                |
|     .914199+.887381ii .350611+.379495ii  .339222+.062212ii |                |
|     .169813+.965004ii .237252+.116721ii  .465736+.40273ii  |                |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+

Generate a random set of flags $G$.

+-------------------------------------------------------+
|i7 : G = randomSchubertProblemInstance({l1,l2,l3},k,n);|
+-------------------------------------------------------+

We solve with respect to $F$.

+-------------------------------------+
|i8 : S = solveSchubertProblem(F,k,n);|
+-------------------------------------+
|i9 : FlagsF = F/last;                |
+-------------------------------------+
|i10 : FlagsG = G/last;               |
+-------------------------------------+

and we transform the solutions to get solutions with respect to $G$

+-----------------------------------------------------------------------------+
|i11 : time S' = changeFlags(S,({l1,l2,l3},FlagsF,FlagsG))                    |
|     -- used 1.82521 seconds                                                 |
|                                                                             |
|o11 = {| .124063-.286284ii   .167867-.0639299ii  .295488-.366109ii   |, |    |
|       | -.25181-.0448108ii  -.107521-.190275ii  -.0896067-.483543ii |  |    |
|       | .219256+.214331ii   .0873511+.372915ii  -.213803+.410917ii  |  |    |
|       | .24818-.0567624ii   .138074+.069527ii   -.446051+.0426311ii |  |    |
|       | -.122857+.030327ii  -.0079778-.488031ii .214077+.374278ii   |  |    |
|       | -.402855+.0597291ii -.43662-.200568ii   -.254234+.748617ii  |  |    |
|      -----------------------------------------------------------------------|
|      -.00839714-.407126ii .205329-.387394ii  .424542-.396438ii  |}          |
|      .192354-.0445916ii   .719274+.437354ii  .49019+.0178286ii  |           |
|      -.396883+.032256ii   -.296361-.56774ii  -.362153+.372505ii |           |
|      .153499+.396506ii    -.494939+.496139ii -.411614+.315486ii |           |
|      -.282532+.248918ii   -.874085+.276867ii -.807461+.498361ii |           |
|      .0284784+.374339ii   -.588673+.906394ii -.233277+.814607ii |           |
|                                                                             |
|o11 : List                                                                   |
+-----------------------------------------------------------------------------+
|i12 : assert all(S', s-> checkIncidenceSolution(s,G))                        |
+-----------------------------------------------------------------------------+

We can also choose a different strategy

+-----------------------------------------------------------------------------+
|i13 : time S' = changeFlags(S,({l1,l2,l3},FlagsF,FlagsG), OneHomotopy=>false)|
|     -- used 1.11693 seconds                                                 |
|                                                                             |
|o13 = {| -.226702-.119043ii  -.326452-.119841ii  .0929953-.230085ii |, |     |
|       | -.229738+.0833434ii -.445398+.0639826ii .150646-.436884ii  |  |     |
|       | .279834-.0761677ii  .402182-.016251ii   -.178732+.299631ii |  |     |
|       | -.119002+.197573ii  -.108802+.642985ii  -.820159-.281606ii |  |     |
|       | -.134096+.0372165ii -.127528-.0349071ii .204901-.0516554ii |  |     |
|       | .499185+.465779ii   1.13857+.442385ii   -.50217+1.18715ii  |  |     |
|      -----------------------------------------------------------------------|
|      .132399-.579396ii   .78366-.359334ii   -.647254+1.41489ii  |}          |
|      -.0614253+.257063ii -.356136+.210321ii .116836-.599086ii   |           |
|      .127487-.876713ii   .739985-1.32758ii  .872113+1.6876ii    |           |
|      -.103026+.750164ii  -.798533+.84669ii  -.0252049-1.72596ii |           |
|      -.0428908-.187959ii .27551-.59017ii    .739685+.785045ii   |           |
|      -.236198+.0362704ii -.341298-.374585ii .878579-.176735ii   |           |
|                                                                             |
|o13 : List                                                                   |
+-----------------------------------------------------------------------------+
|i14 : assert all(S', s-> checkIncidenceSolution(s,G))                        |
+-----------------------------------------------------------------------------+

Caveat
======

There are two strategies: when OneHomotopy, is set to
true (Macaulay2Doc), (default) it uses straight line homotopies to change
flags, but assumes the initial flags are generic.

When OneHomotopy, is set to false (Macaulay2Doc),
it makes gradual changes in the flags by changing one
column at a time, and using only linear homotopies, but in this setting, it
generates polynomial equations using all minors of the incidence conditions
(thus is not very effective).

See also
========

  * randomSchubertProblemInstance, --
    returns a random instance of a given Schubert problem
  * solveSchubertProblem -- uses
    Littlewood-Richardson homotopy algorithm to solve a Schubert problem
  * checkIncidenceSolution -- check if a
    solution satisfies an instance of a Schubert problem

Ways to use changeFlags :
=========================

  * "changeFlags(List,Sequence)"
  * changeFlags(Matrix,List,Sequence)
    -- recursive call of change
    flags

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

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

changeFlags(...,OneHomotopy=>...) -- strategy for moving solutions to a Schubert problem
****************************************************************************************

Synopsis
========

  * Usage:
        changeFlags(...,OneHomotopy=>T)
  * Inputs:
      * T, a Boolean value (Macaulay2Doc), when true [default]
        it uses a single straight line homotopy, otherwise it makes a gradual
        change in the flags, one column at a time.

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

There are two strategies: when OneHomotopy is set to true (default) it uses
straight line homotopies to change flags, but assumes the initial flags are
generic.

When OneHomotopy is set to false, it makes gradual changes in the flags by
changing one column at a time, and using only linear homotopies, but in this
setting, it generates polynomial equations using all minors of the incidence
conditions (thus is not very effective).

Further information
===================

  * Default value: true (Macaulay2Doc),
  * Function: changeFlags, -- continue solutions of a
    Schubert problem to another instance
  * Option key: OneHomotopy, -- strategy for changing flags.

Functions with optional argument named OneHomotopy :
====================================================

  * changeFlags(...,OneHomotopy=>...)
    -- strategy for moving
    solutions to a Schubert problem

changeFlags(Matrix,List,Sequence) -- recursive call of change flags
*******************************************************************

Synopsis
========

  * Function: changeFlags,
  * Usage:
        changeFlags(MX,SolsF,CFG)
  * Inputs:
      * MX, a matrix (Macaulay2Doc), matrix of local coordinates
      * SolsF, a list (Macaulay2Doc), solutions with respect to
        flags F
      * CFG, a sequence (Macaulay2Doc), a triple (C,F,G) where
        C is a list of m Schubert conditions, F is a list of m flags defining
        an instance with solution set sols, G is a list of m flags defining the
        instance whose solutions we want.
  * Optional inputs (Macaulay2Doc),:
      * OneHomotopy,
        => ..., default value true, strategy for moving solutions to a Schubert
        problem
  * Outputs:
      * a list (Macaulay2Doc), solutions of the problem C with
        respect to flags G.

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

  * changeFlags(Matrix,List,Sequence)
    -- recursive call of change
    flags

checkIncidenceSolution -- check if a solution satisfies an instance of a Schubert problem
*****************************************************************************************

Synopsis
========

  * Usage:
        checkIncidenceSolution(s, P)
  * Inputs:
      * P, a list (Macaulay2Doc), An instance of a Schubert problem
        as a list {($l_1,F_1$),...,($l_m,F_m$)}
      * s, a matrix (Macaulay2Doc), A matrix of size $n\times k$
        representing a solution to the Schubert problem P
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if s satisfies all
        the incidence conditions

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

For each pair $(l,F)$ in the Schubert problem $P$, where $l$ is a Schubert
condition given as a partition, and $F$ is a flag given as an $n \times n$
matrix, the function verifies if the matrix $s$ satisfies the incidence
conditions imposed by $l$ with respect to the flag $F$, for each of the pairs
in $P$, by computing the corresponding minor conditions.

Caveat
======

This function was created for testing purposes and will be deleted later as it
may not be numerically stable.

Ways to use checkIncidenceSolution :
====================================

  * "checkIncidenceSolution(Matrix,List)"

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

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

LRcheater -- A cheater's homotopy to a real Schubert triple intersection problem
********************************************************************************

Synopsis
========

  * Usage:
        t = LRcheater(n,m,w)
  * Inputs:
      * n, an integer (Macaulay2Doc), the ambient dimension
      * m, a matrix (Macaulay2Doc), in the rows are the
        intersection conditions, the first element of each row is the number of
        times the intersection bracket must be taken.
      * w, a string (Macaulay2Doc), the outcome of LRtriple(n,m),
        wrapped into string.
  * Optional inputs (Macaulay2Doc),:
      * Verbose, =>
        ..., default value true, request verbose feedback
  * Outputs:
      * t, a string (Macaulay2Doc), solutions to a a real triple
        Schubert intersection problem.

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

A cheater's homotopy between two polynomial systems connects a generic instance
to a specific instance. This is similar in function to changeFlags,

The example below solves a generic instance of [2 4 6]^3, followed by a cheater
homotopy to a real instance.

+-------------------------------+
|i1 : R := ZZ;                  |
+-------------------------------+
|i2 : n := 6;                   |
+-------------------------------+
|i3 : m := matrix{{3, 2, 4, 6}};|
|                               |
|              1        4       |
|o3 : Matrix ZZ  <--- ZZ        |
+-------------------------------+
|i4 : t := LRtriple(n,m);       |
+-------------------------------+
|i5 : w := wrapTriplet(t);      |
+-------------------------------+

Ways to use LRcheater :
=======================

  * "LRcheater(ZZ,Matrix,String)"

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

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

LRhomotopies -- interface to the Littlewood-Richardson homotopies in PHCpack
****************************************************************************

Interfaces the functionality of the software PHCpack to solve Schubert problems
with Littlewood-Richardson homotopies, a tool in numerical Schubert calculus.
The software PHCpack is available at
http://www.math.uic.edu/~jan/download.html. The site provides source code and
its executable versions phc. The user must have the executable program phc
available, preferably in the execution path.

Caveat
======

The program "phc" (at least version 2.4.27, but preferably higher) of PHCpack
needs to in the path for execution.

LRnumber -- returns the number of solutions to the given Schubert problem
*************************************************************************

Synopsis
========

  * Usage:
        LRnumber(conditions,k,n)
  * Inputs:
      * conditions, a list (Macaulay2Doc), of Schubert conditions,
        either partitions or brackets, that constitutes a Schubert problem on
        the Grassmannian $Gr(k,n)$.
      * k, an integer (Macaulay2Doc),
      * n, an integer (Macaulay2Doc), $k$ and $n$ define the
        Grassmannian $Gr(k,n)$ of $k$-planes in $n$-space
  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ...,
        default value "Schubert2", strategy for computing the number of
        solutions to a Schubert problem
  * Outputs:
      * an integer (Macaulay2Doc), The number of solutions to the
        given Schubert problem

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

This first verifies that the conditions are either all partitions or all
brackets, and that they form a Schubert problem on $Gr(k,n)$.

Then it computes the intersection number of the product of Schubert classes in
the cohomology ring of the Grassmannian

For instance, the problem of four lines is given by 4 partitions {1}$^4$ in
$Gr(2,4)$

+------------------------------------+
|i1 : LRnumber({{1},{1},{1},{1}},2,4)|
|                                    |
|o1 = 2                              |
+------------------------------------+

the same problem but using brackets instead of partitions

+--------------------------------------------+
|i2 : LRnumber({{2,4},{2,4},{2,4},{2,4}},2,4)|
|                                            |
|o2 = 2                                      |
+--------------------------------------------+

the same problem but using phc implementation of Littlewood-Richardson rule

+------------------------------------------------------+
|i3 : LRnumber({{1},{1},{1},{1}},2,4,Strategy => "phc")|
|                                                      |
|o3 = 2                                                |
+------------------------------------------------------+

Caveat
======

This uses the package Schubert2 and the Strategy "phc" requires the string
parsing capabilities of Macaulay2 version 1.17 or later

See also
========

  * LRrule -- computes the product of Schubert classes using
    geometric Littlewood-Richardson rule

Ways to use LRnumber :
======================

  * "LRnumber(List,ZZ,ZZ)"

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

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

LRnumber(...,Strategy=>...) -- strategy for computing the number of solutions to a Schubert problem
***************************************************************************************************

Synopsis
========

  * Usage:
        LRnumber(...,Strategy=>S)
  * Inputs:
      * S, a string (Macaulay2Doc), "Schubert2", the default
        value, or "phc".

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

Determines which method to compute the number of solutions is created.

"Schubert2" uses the SchubertRings command from the package Schubert2,
[default]

"phc" uses LRrule, the implementation of the geometric
Littlewood-Richardson rule in PHCPack. This also requires the string parsing
capabilities of Macaulay2 version 1.17 or later

Further information
===================

  * Default value: Schubert2
  * Function: LRnumber, -- returns the number of solutions to
    the given Schubert problem
  * Option key: Strategy (Macaulay2Doc), -- an optional argument

Functions with optional argument named Strategy :
=================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * "annihilator(...,Strategy=>...)" -- see annihilator (Saturation),
    -- the annihilator ideal
  * "associatedPrimes(...,Strategy=>...)" -- see associatedPrimes (PrimaryDecomposition),
    -- find associated primes
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hermite(...,Strategy=>...) (missing documentation)
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "idealizer(...,Strategy=>...)" -- see idealizer (IntegralClosure),
    -- compute Hom(I,I) as a quotient ring
  * integralClosure(...,Strategy=>...) (IntegralClosure),
    --
    control the algorithm used
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersectInP(...,Strategy=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "isPrimary(...,Strategy=>...)" -- see isPrimary (PrimaryDecomposition),
    -- determine whether a submodule is
    primary
  * "isPrime(Ideal,Strategy=>...)" -- see isPrime(Ideal) (MinimalPrimes),
    -- whether an ideal is prime
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * "localize(...,Strategy=>...)" -- see localize (PrimaryDecomposition),
    -- localize an ideal at a prime ideal
  * LRnumber(...,Strategy=>...)
    -- strategy for computing
    the number of solutions to a Schubert problem
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * "decompose(Ideal,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "minimalPrimes(...,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "primaryComponent(...,Strategy=>...)" -- see primaryComponent (PrimaryDecomposition),
    -- find a primary component
    corresponding to an associated prime
  * pushForward(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (Saturation)
  * "radical(...,Strategy=>...)" -- see radical (MinimalPrimes),
    -- the radical of an ideal
  * "radicalContainment(...,Strategy=>...)" -- see radicalContainment (MinimalPrimes),
    -- whether an element is contained in
    the radical of an ideal
  * randomSchubertProblemInstance(...,Strategy=>...),
    --
    strategy for creating a random matrix representing a flag
  * "analyticSpread(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "distinguished(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isLinearType(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isReduction(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "minimalReduction(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "multiplicity(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "normalCone(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "reesAlgebra(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * reesIdeal(...,Strategy=>...) (ReesAlgebra)
    -- Choose a
    strategy for the saturation step
  * "specialFiber(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "specialFiberIdeal(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "regSeqInIdeal(...,Strategy=>...)" -- see regSeqInIdeal (PrimaryDecomposition),
    -- a regular sequence contained in an
    ideal
  * resolution(...,Strategy=>...) (Macaulay2Doc)
  * saturate(...,Strategy=>...) (Saturation)
  * "primaryDecomposition(...,Strategy=>...)" -- see strategies for computing primary decomposition (PrimaryDecomposition),
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix
  * "tangentCone(...,Strategy=>...)" -- see tangentCone(Ideal) (TangentCone),

LRrule -- computes the product of Schubert classes using geometric Littlewood-Richardson rule
*********************************************************************************************

Synopsis
========

  * Usage:
        s = LRrule(n,M)
  * Inputs:
      * n, an integer (Macaulay2Doc), the dimension of the ambient
        space of the Grassmannian $Gr(k,n)$.
      * M, a matrix (Macaulay2Doc), whose rows encode Schubert
        conditions. Each row is a $k+1$-tuple, {m,b}, where $m$ is a nonegative
        integer and $b$ a bracket (see bracket2partition,
        for details). The bracket $b$ represents a Schubert
        condition and $m$ is its multiplicity.
  * Optional inputs (Macaulay2Doc),:
      * Verbose, =>
        ..., default value false, request verbose feedback
  * Outputs:
      * s, a string (Macaulay2Doc), contains an equation, with at
        the left the product of Schubert conditions and at the right the result
        as a formal sum of brackets.

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

LRrule uses the geometric Littlewood-Richardson rule to compute a product in
the Chow ring of the Grassmannian. This writes a product of brackets as a
formal sum of brackets, which represents an intersection of Schubert varieties
as a formal sum of Schubert varieties. When the input matrix M is a Schubert
problem, this gives the number of solutions to that Schubert problem. The
command LRnumber, calls LRrule and extracts the number of
solutions.

+-------------------------------------------+
|i1 : R = ZZ;                               |
+-------------------------------------------+
|i2 : n = 7;                                |
+-------------------------------------------+
|i3 : M = matrix{{3, 3, 6, 7},{2, 3, 5, 7}};|
|                                           |
|              2        4                   |
|o3 : Matrix ZZ  <--- ZZ                    |
+-------------------------------------------+
|i4 : LRrule(n,M)                           |
|                                           |
|o4 = [ 3 6 7 ]^3*[ 3 5 7 ]^2 = +10[1 2 3]  |
+-------------------------------------------+

The output: [ 3 6 7 ]^3*[ 3 5 7 ]^2 = +10[1 2 3] means that the Schubert
problem [ 3 6 7 ]^3*[ 3 5 7 ]^2 in multiplicative form has 10 solution
3-planes.   That is, there are 10 3-planes that satisfy three Schubert
conditions given by the bracket [3, 6, 7] and two conditions given by the
bracket [3, 5, 7].

More generally, this computes a product in the Chow ring:

+------------------------------------------------------------------+
|i5 : LRrule(7, matrix{{2,3,6,7},{1,3,5,7},{1,2,5,7}})             |
|                                                                  |
|o5 = [ 3 6 7 ]^2*[ 3 5 7 ]*[ 2 5 7 ] = +2[1 2 4]+4[1 2 4]+2[1 2 4]|
+------------------------------------------------------------------+

Caveat
======

The Littlewood-Richardson homotopy algorithm requires a Schubert problems (sum
of codimensions equals the dimension of the Grassmannian).

Ways to use LRrule :
====================

  * "LRrule(ZZ,Matrix)"

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

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

LRtriple -- uses Littlewood-Richardson homotopy algorithm to solve a Schubert problem
*************************************************************************************

Synopsis
========

  * Usage:
        LRtriple(n,M)
        LRtriple(n,M, RandomSeed=>12345)
        LRtriple(n,M, WorkingPrecision=>2)
  * Inputs:
      * n, an integer (Macaulay2Doc), the dimension of the ambient
        space of the Grassmannian $Gr(k,n)$.
      * M, a matrix (Macaulay2Doc), whose rows encode the
        Schubert condition. Each row is a $k+1$-tuple, $\{m,b\}$, where $m$ is
        a nonegative integer and $b$ a bracket (see bracket2partition for
        details). The bracket $b$ represents a Schubert condition and $m$ is
        its multiplicity in this Schubert problem.
  * Optional inputs (Macaulay2Doc),:
      * RandomSeed, =>
        ..., default value -1, option to set the seed of the random number
        generators.
      * Verbose, =>
        ..., default value false, request verbose feedback
      * WorkingPrecision, => ..., default value 0,
        option to raise the working precision to double double or quad double.
  * Outputs:
      * a sequence (Macaulay2Doc), first a string with the
        generic flags, the moved flags, and the solution planes; then a string
        with the polynomial system solved; and thirdly a list of solutions.

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

LRtriple applies the Littlewood-Richardson homotopies to solve a generic
instance of a Schubert problem defined by at least three Schubert conditions.
The flags defining the instance are generated in the routine.

Use the method parseTriplet to parse the three strings f, p, and s into proper
Macaulay2 polynomials, solution lists, and complex matrices.

The Schubert problem  [2 4 6]^3 on $G(3,6)$ has two solutions. This example
computes the solutions to an instance given by random flags.

+-----------------------------------------------------------------------------+
|i1 : R := ZZ; n := 6; m := matrix{{3, 2, 4, 6}};                             |
|                                                                             |
|              1        4                                                     |
|o3 : Matrix ZZ  <--- ZZ                                                      |
+-----------------------------------------------------------------------------+
|i4 : result := LRtriple(n,m);                                                |
+-----------------------------------------------------------------------------+
|i5 : stdio << "the fixed flags :\n" << result_0;                             |
|the fixed flags :                                                            |
| -4.08248290463863E-01   0.00000000000000E+00 -4.72085446817433E-02          |
|  5.56878874843095E-02  -4.04432350157850E-01 -3.66114997609468E-01          |
| -4.08144702499215E-01  -9.19611268385567E-03  4.10229510257585E-01          |
|  4.07285703592482E-01   2.80182496927228E-02  3.93751341331076E-01          |
|  7.07399797116559E-02  -4.02072781890370E-01 -1.63799171362049E-01          |
|  1.95687898368325E-02  -4.07779019974040E-01  4.34733836676498E-02          |
|                                                                             |
|THE MOVED FLAG :                                                             |
|  1  1  1  1  1  1                                                           |
| -1 -1 -1 -1 -1  0                                                           |
|  1  1  1  1  0  0                                                           |
| -1 -1 -1  0  0  0                                                           |
|  1  1  0  0  0  0                                                           |
| -1  0  0  0  0  0                                                           |
|                                                                             |
|THE 3-SOLUTION PLANES :                                                      |
| -1.07700499041284E+00  -8.11068437983347E-01  0.00000000000000E+00          |
|  1.00000000000000E+00   0.00000000000000E+00  0.00000000000000E+00          |
|  0.00000000000000E+00   0.00000000000000E+00 -3.36987250104405E-01          |
|  0.00000000000000E+00   0.00000000000000E+00  1.00000000000000E+00          |
|  0.00000000000000E+00   0.00000000000000E+00  0.00000000000000E+00          |
|  0.00000000000000E+00   0.00000000000000E+00  0.00000000000000E+00          |
|                                                                             |
| -2.39519267028103E-01  -1.10486524678214E-01  0.00000000000000E+00          |
|  1.00000000000000E+00   0.00000000000000E+00  0.00000000000000E+00          |
|  0.00000000000000E+00   0.00000000000000E+00  9.63898127100209E-01          |
|  0.00000000000000E+00   0.00000000000000E+00  1.00000000000000E+00          |
|  0.00000000000000E+00   0.00000000000000E+00  0.00000000000000E+00          |
|  0.00000000000000E+00   0.00000000000000E+00  0.00000000000000E+00          |
|-----------------------------------------------------------------------------|
|-4.52979868649730E-01  5.41161724926203E-01  -2.47207907529739E-01           |
| 4.35493465632689E-03 -3.75466323350980E-01  -1.79353949734268E-02           |
|-6.62199849777962E-02 -5.36673520388478E-01   1.89377380436866E-03           |
|-6.44629036508820E-02  1.29747517901737E-01   8.16212381454746E-03           |
| 3.60900238276350E-01  3.63851850002974E-01   9.76101469078975E-02           |
|-4.09491669168698E-01 -2.35872346804551E-01   4.75482230671679E-02           |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
| 0.00000000000000E+00  0.00000000000000E+00   0.00000000000000E+00           |
| 0.00000000000000E+00  0.00000000000000E+00   0.00000000000000E+00           |
|-1.67450845937719E-01  0.00000000000000E+00   0.00000000000000E+00           |
| 0.00000000000000E+00  0.00000000000000E+00   0.00000000000000E+00           |
| 0.00000000000000E+00 -2.30564287152720E-01   5.64924049337573E-03           |
| 0.00000000000000E+00  1.00000000000000E+00   0.00000000000000E+00           |
|                                                                             |
| 0.00000000000000E+00  0.00000000000000E+00   0.00000000000000E+00           |
| 0.00000000000000E+00  0.00000000000000E+00   0.00000000000000E+00           |
|-3.01351874683110E-01  0.00000000000000E+00   0.00000000000000E+00           |
| 0.00000000000000E+00  0.00000000000000E+00   0.00000000000000E+00           |
| 0.00000000000000E+00 -1.15368987352860E+00   1.20932611395459E+00           |
| 0.00000000000000E+00  1.00000000000000E+00   0.00000000000000E+00           |
|-----------------------------------------------------------------------------|
|-1.32176911249782E-01  -2.28201970805131E-01  2.36139472149256E-01           |
|-3.37089456589007E-01   1.09184570046039E-02  6.32916047119544E-01           |
|-2.11007715043063E-01  -5.35167787516717E-01 -1.09738691803618E-01           |
|-7.55415659355416E-02   3.88600945732782E-02  3.64892907685067E-01           |
|-5.26311952003756E-01  -2.38646826009220E-01 -3.98618871807167E-01           |
| 7.19019396782173E-02   3.73406870789826E-01 -4.16896522749570E-01           |
|-----------------------------------------------------------------------------|
|-1.87739864365389E-01  3.11759017480660E-01   1.19153245292991E-01           |
| 1.43190422050627E-01  8.50317067363224E-02   1.26144412375443E-01           |
|-4.88064910019195E-02  1.81938450320808E-04  -1.65180017628623E-01           |
|-5.78270817076200E-02  2.25708083950237E-01  -6.80136111500466E-01           |
| 5.41111688686785E-02  4.75305531754421E-02  -1.90519074761423E-01           |
| 3.69117815129642E-02  5.34441821546929E-01  -2.16227340369752E-02           |
+-----------------------------------------------------------------------------+
|i6 : stdio << "polynomial system solved :\n" << result_1;                    |
|polynomial system solved :                                                   |
| 6 3                                                                         |
|                                                                             |
|+( 2.26456764896410E-02 + 2.49844937328485E-01*i)*x11*x32*x53                |
|+( 3.15777245187067E-01 + 9.66166977235230E-03*i)*x11*x32                    |
|+(-2.18039974912898E-01 + 5.72681877540543E-02*i)*x11*x53                    |
|+( 1.09626716659595E-01 - 2.97017034585406E-01*i)*x32*x53                    |
|+( 1.52355901543258E-01 + 2.09468425437531E-01*i)*x11                        |
|+(-3.11325662430988E-01 - 3.22301515871292E-01*i)*x32                        |
|+(-2.66953639602332E-01 + 1.27177783632620E-02*i)*x53                        |
|+(-1.64152368621853E-01 + 1.07777676474340E-01*i);                           |
|                                                                             |
|+(-1.35742889778990E-01 + 2.17682459193376E-01*i)*x11*x32*x53                |
|+( 1.71921548377550E-01 - 8.29071611236532E-02*i)*x11*x32                    |
|+( 2.70820739191635E-01 - 1.07243745128727E-01*i)*x11*x53                    |
|+(-1.02921496859705E-01 + 2.90239027460114E-01*i)*x32*x53                    |
|+( 3.94198672213008E-01 - 3.98958519352494E-01*i)*x11                        |
|+( 3.22090999358762E-02 + 1.39423752602463E-01*i)*x32                        |
|+( 2.41226791120785E-01 - 2.59403039422168E-02*i)*x53                        |
|+( 6.15363963064252E-01 - 1.67078635461445E-01*i);                           |
|                                                                             |
|+( 3.09510704039293E-01 - 5.95168448036128E-01*i)*x11*x32*x53                |
|+( 3.36210442667399E-01 + 7.05987643216428E-03*i)*x11*x32                    |
|+(-1.11225261790743E-01 - 2.54560554556378E-01*i)*x11*x53                    |
|+( 2.28103938452441E-01 - 2.08980888394715E-02*i)*x32*x53                    |
|+( 1.41695965472263E-01 + 4.00079612516609E-02*i)*x11                        |
|+( 2.57165526542390E-01 + 2.88186394666915E-01*i)*x32                        |
|+(-1.67148338603389E-01 + 1.76966921330865E-01*i)*x53                        |
|+( 8.97253197565314E-02 + 2.62865341036959E-01*i);                           |
|                                                                             |
|+( 2.81681822921272E-01 + 8.66231982908467E-01*i)*x11*x32*x53                |
|+( 2.28809384623938E-01 + 5.32114920885280E-01*i)*x11*x32                    |
|+(-5.86367688889768E-01 + 3.15425474457949E-01*i)*x11*x53                    |
|+( 2.08919157440114E-01 + 3.96158762546460E-01*i)*x32*x53                    |
|+(-2.12864431021167E-01 + 1.96129322290429E-01*i)*x11                        |
|+( 1.69504223981375E-01 + 2.30815036927011E-01*i)*x32                        |
|+(-3.92511753956552E-01 - 2.50775379441183E-02*i)*x53                        |
|+(-1.41619353187752E-01 - 1.92988534627778E-02*i);                           |
|                                                                             |
|+(-5.55613554896697E-01 + 9.58350943486976E-02*i)*x11*x32*x53                |
|+(-4.86062825888290E-01 + 2.30140984236890E-01*i)*x11*x32                    |
|+(-3.32649167951689E-01 - 5.22180313407958E-02*i)*x11*x53                    |
|+(-1.46716505023529E-01 + 3.18264494923420E-01*i)*x32*x53                    |
|+(-2.99897684682840E-01 - 2.31528698367347E-01*i)*x11                        |
|+(-1.13823522219086E-01 + 3.90394031670838E-01*i)*x32                        |
|+(-1.87140101166406E-01 - 2.37420886733269E-01*i)*x53                        |
|+(-1.11414879522674E-02 - 2.63936409999584E-01*i);                           |
|                                                                             |
|+( 3.46124123545673E-01 - 8.16809752626568E-02*i)*x11*x32*x53                |
|+( 6.68268421197837E-03 - 6.45761479639423E-01*i)*x11*x32                    |
|+(-1.69153698627581E-01 + 2.28277756848134E-01*i)*x11*x53                    |
|+( 1.93501124916598E-01 + 7.71025618738563E-02*i)*x32*x53                    |
|+( 3.15408036580370E-01 - 2.33880697858375E-01*i)*x11                        |
|+(-6.19712747216821E-03 - 1.90642624043654E-01*i)*x32                        |
|+(-1.72863621209133E-01 + 1.14694130775271E-01*i)*x53                        |
|+( 3.24681386619333E-01 + 1.00680402675064E-01*i);                           |
|                                                                             |
|ROOT REFINING PARAMETERS                                                     |
|  1. output during the iterations    :  no                                   |
|  2. deflate isolated singularities  :  yes                                  |
|  3. tolerance for error on the root :  1.000E-08                            |
|  4. tolerance for the residual      :  1.000E-08                            |
|  5. tolerance for singular roots    :  1.000E-08                            |
|  6. maximum number of iterations    :  3                                    |
+-----------------------------------------------------------------------------+
|i7 : stdio << "solutions :\n" << result_2;                                   |
|solutions :                                                                  |
|                                                                             |
|2 3                                                                          |
|===========================================================================  |
|solution 1 :    start residual :  1.693E-15   #iterations : 1   success      |
|t :  1.00000000000000E+00   0.00000000000000E+00                             |
|m : 1                                                                        |
|the solution for t :                                                         |
| x11 : -1.07700499041284E+00  -8.11068437983347E-01                          |
| x32 : -3.36987250104405E-01  -1.67450845937719E-01                          |
| x53 : -2.30564287152720E-01   5.64924049337642E-03                          |
|== err :  4.712E-17 = rco :  2.862E-01 = res :  1.249E-16 = complex regular =|
|solution 2 :    start residual :  3.886E-15   #iterations : 1   success      |
|t :  1.00000000000000E+00   0.00000000000000E+00                             |
|m : 1                                                                        |
|the solution for t :                                                         |
| x11 : -2.39519267028103E-01  -1.10486524678215E-01                          |
| x32 :  9.63898127100208E-01  -3.01351874683111E-01                          |
| x53 : -1.15368987352860E+00   1.20932611395459E+00                          |
|== err :  2.362E-16 = rco :  2.105E-01 = res :  3.331E-16 = complex regular =|
|===========================================================================  |
|A list of 2 solutions has been refined :                                     |
|Number of regular solutions     : 2.                                         |
|Number of singular solutions    : 0.                                         |
|Number of real solutions        : 0.                                         |
|Number of complex solutions     : 2.                                         |
|Number of clustered solutions   : 0.                                         |
|Number of solutions at infinity : 0.                                         |
|Number of failures              : 0.                                         |
|===========================================================================  |
|Frequency tables for correction, residual, and condition numbers :           |
|FreqCorr :  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 : 2                              |
|FreqResi :  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 : 2                              |
|FreqCond :  2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 : 2                              |
|Small correction terms and residuals counted to the right.                   |
|Well conditioned and distinct roots counted to the left.                     |
|                                                                             |
|THE SOLUTIONS :                                                              |
|2 3                                                                          |
|===========================================================================  |
|solution 1 :                                                                 |
|t :  1.00000000000000E+00   0.00000000000000E+00                             |
|m : 1                                                                        |
|the solution for t :                                                         |
| x11 : -1.07700499041284E+00  -8.11068437983347E-01                          |
| x32 : -3.36987250104405E-01  -1.67450845937719E-01                          |
| x53 : -2.30564287152720E-01   5.64924049337642E-03                          |
|== err :  4.712E-17 = rco :  2.862E-01 = res :  1.249E-16 ==                 |
|solution 2 :                                                                 |
|t :  1.00000000000000E+00   0.00000000000000E+00                             |
|m : 1                                                                        |
|the solution for t :                                                         |
| x11 : -2.39519267028103E-01  -1.10486524678215E-01                          |
| x32 :  9.63898127100208E-01  -3.01351874683111E-01                          |
| x53 : -1.15368987352860E+00   1.20932611395459E+00                          |
|== err :  2.362E-16 = rco :  2.105E-01 = res :  3.331E-16 ==                 |
|                                                                             |
|TIMING INFORMATION for Root refining                                         |
|The elapsed time in seconds was                  0.000470000 =  0h 0m 0s  0ms|
|User time in seconds was                         0.000411000 =  0h 0m 0s  0ms|
|System CPU time in seconds was                   0.000059000 =  0h 0m 0s  0ms|
|Non-I/O page faults was                                  28                  |
|I/O page faults was                                       0                  |
|Signals delivered was                                     0                  |
|Swaps was                                                 0                  |
|Total context switches was                                1                  |
|                                                                             |
|TIMING INFORMATION for resolving a Schubert problem                          |
|The elapsed time in seconds was                  0.008962000 =  0h 0m 0s  9ms|
|User time in seconds was                         0.008770000 =  0h 0m 0s  9ms|
|System CPU time in seconds was                   0.000192000 =  0h 0m 0s  0ms|
|Non-I/O page faults was                                 178                  |
|I/O page faults was                                       0                  |
|Signals delivered was                                     0                  |
|Swaps was                                                 0                  |
|Total context switches was                                3                  |
|                                                                             |
|Seed used in random number generators : 82707.                               |
|PHCv2.4.77 released 2020-06-12                                               |
|-----------------------------------------------------------------------------|
|=                                                                            |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|=                                                                            |
+-----------------------------------------------------------------------------+

Ways to use LRtriple :
======================

  * "LRtriple(ZZ,Matrix)"

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

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

LRtriple(...,RandomSeed=>...) -- option to set the seed of the random number generators.
****************************************************************************************

Synopsis
========

  * Usage:
        LRtriple(...,RandomSeed=>ZZ)

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

Use RandomSeed=>12345 to set the seed to 12345. This can be used to make the
generation of random flas deterministic and hence reproducible.

Further information
===================

  * Default value: -1
  * Function: LRtriple, -- uses Littlewood-Richardson homotopy
    algorithm to solve a Schubert problem
  * Option key: RandomSeed, -- seed for the random number
    generators.

Functions with optional argument named RandomSeed :
===================================================

  * LRtriple(...,RandomSeed=>...)
    -- option to set the seed
    of the random number generators.

NSC2phc -- dictionary between different notations for Schubert problems.
************************************************************************

Synopsis
========

  * Usage:
        M = NSC2phc(conds,k,n)
  * Inputs:
      * conds, a list (Macaulay2Doc), of Schubert conditions,
        either partitions or brackets, that constitutes a Schubert problem on
        the Grassmannian $Gr(k,n)$
      * k, an integer (Macaulay2Doc),
      * n, an integer (Macaulay2Doc), $k$ and $n$ represent the
        Grassmannian $Gr(k,n)$
  * Outputs:
      * a matrix (Macaulay2Doc), the corresponding Schubert
        problem in notation for PHCPack implementation of Littlewood-Richardson
        rule and homotopies. Its rows encode Schubert conditions with
        multiplicities. Each row is a $k+1$-tuple, {m,b}, where $m$ is a
        nonegative integer and $b$ a bracket (see  bracket2partition,
        for details). The bracket $b$ represents a Schubert
        condition and $m$ is its multiplicity in this Schubert intersection
        problem.

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

A Schubert problem in the Grassmannian $Gr(k,n)$ is encoded by either a list of
partitions or brackets whose codimensions sum to $k(n-k)$. (see
bracket2partition, for details on brackets and partitions)

The PHCPack implementations of the geometric Littlewood-Richardson rule encode
the brackets in a matrix, where each row has the form ${m, b}$ with $m$ the
multiplicity of the bracket $b$, which is a strictly increasing sequence of $k$
integers between $1$ and $n$.

+-----------------------------------------------------------------------------+
|i1 : k=4;                                                                    |
+-----------------------------------------------------------------------------+
|i2 : n = 8;                                                                  |
+-----------------------------------------------------------------------------+
|i3 : SchubProbP = {{2,2},{2,2},{2,2},{1},{1},{1},{1}}                        |
|                                                                             |
|o3 = {{2, 2}, {2, 2}, {2, 2}, {1}, {1}, {1}, {1}}                            |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : NSC2phc(SchubProbP,k,n)                                                 |
|                                                                             |
|o4 = | 3 3 4 7 8 |                                                           |
|     | 4 4 6 7 8 |                                                           |
|                                                                             |
|              2        5                                                     |
|o4 : Matrix ZZ  <--- ZZ                                                      |
+-----------------------------------------------------------------------------+
|i5 : k=4;                                                                    |
+-----------------------------------------------------------------------------+
|i6 : n = 8;                                                                  |
+-----------------------------------------------------------------------------+
|i7 : SchubProbB = {{3,4,7,8},{3,4,7,8},{3,4,7,8},{4,6,7,8},{4,6,7,8},{4,6,7,8|
|                                                                             |
|o7 = {{3, 4, 7, 8}, {3, 4, 7, 8}, {3, 4, 7, 8}, {4, 6, 7, 8}, {4, 6, 7, 8},  |
|     ------------------------------------------------------------------------|
|     {4, 6, 7, 8}, {4, 6, 7, 8}}                                             |
|                                                                             |
|o7 : List                                                                    |
|-----------------------------------------------------------------------------|
|},{4,6,7,8}}                                                                 |
+-----------------------------------------------------------------------------+
|i8 : NSC2phc(SchubProbB,4,8)                                                 |
|                                                                             |
|o8 = | 3 3 4 7 8 |                                                           |
|     | 4 4 6 7 8 |                                                           |
|                                                                             |
|              2        5                                                     |
|o8 : Matrix ZZ  <--- ZZ                                                      |
+-----------------------------------------------------------------------------+

See also
========

  * LRrule -- computes the product of Schubert classes using
    geometric Littlewood-Richardson rule

Ways to use NSC2phc :
=====================

  * "NSC2phc(List,ZZ,ZZ)"

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

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

OneHomotopy -- strategy for changing flags.
*******************************************

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

There are two strategies to change flags: when OneHomotopy is set to true
(default) it uses straight line homotopies to change flags, but assumes the
initial flags are generic.

When OneHomotopy is set to false, it makes gradual changes in the flags by
changing one column at a time, and using only linear homotopies, but in this
setting, it generates polynomial equations using all minors of the incidence
conditions (thus is not very effective).

Functions with optional argument named OneHomotopy :
====================================================

  * changeFlags(...,OneHomotopy=>...)
    -- strategy for moving
    solutions to a Schubert problem

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

The object OneHomotopy, is a symbol (Macaulay2Doc).

parseTriplet -- Parses the output from LRtriple into Macaulay2 objects.
***********************************************************************

Synopsis
========

  * Usage:
        (R, pols, sols, fixedFlags, movedFlag, solutionPlanes) = parseTriplet(f, p, s)
  * Inputs:
      * f, a string (Macaulay2Doc), represents the fixed flag.
      * p, a string (Macaulay2Doc), represents a polynomial
        system.
      * s, a string (Macaulay2Doc), solutions to the polynomial
        system.
  * Optional inputs (Macaulay2Doc),:
      * Verbose, =>
        ..., default value false, request verbose feedback
  * Outputs:
      * R, a ring (Macaulay2Doc), a polynomial ring with complex
        floating-point coefficients and in the variables used in the systems p.
      * pols, a list (Macaulay2Doc), list of polynomial equations
        in the ring R.
      * sols, a list (Macaulay2Doc), list of solutions of the
        system pols.
      * fixedFlags, a list (Macaulay2Doc), list of the fixed flags,
        as matrices of complex numbers.
      * movedFlag, a list (Macaulay2Doc), the moved flag, the flag
        not listed here is the identity matrix.
      * solutionPlanes, a list (Macaulay2Doc), list of complex
        matrices which store the solution planes.

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

parseTriplet processes the output of LRtriple for other methods in
NumericalSchubertCalculus.

+-----------------------------------------------------------------------------+
|i1 : (f, p, s) = LRtriple(6,matrix{{3, 2, 4, 6}});                           |
+-----------------------------------------------------------------------------+
|i2 : (R, pols, sols, fixedFlags, movedFlag, solutionPlanes) = parseTriplet(f,|
|                                                                             |
|o2 = (R, {(- .0399744 - .0145143*ii)x11*x32*x53 + (.0926769 +                |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     .354494*ii)x11*x32 + (- .632386 + .186907*ii)x11*x53 + (.0228595 +      |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     .0537889*ii)x32*x53 + (.406348 + .234116*ii)x11 + (- .0652501 -         |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     .0138565*ii)x32 + (- .249868 + .134704*ii)x53 + .211821 - .165463*ii,   |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     (.0933272 - .373609*ii)x11*x32*x53 + (.264606 - .401113*ii)x11*x32 + (- |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     .0939123 - .679424*ii)x11*x53 + (.0455688 - .0119688*ii)x32*x53 +       |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     (.0451169 - .683975*ii)x11 + (.0388899 + .0672329*ii)x32 + (- .110409 - |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     .0867227*ii)x53 - .341856 - .148787*ii, (- .590604 +                    |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     .0241807*ii)x11*x32*x53 + (- .13432 - .00692575*ii)x11*x32 + (.0566638 -|
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     .0743429*ii)x11*x53 + (- .497876 - .197278*ii)x32*x53 + (.39268 -       |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     .106231*ii)x11 + (- .0559863 - .0344225*ii)x32 + (.207618 +             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     .0018821*ii)x53 + .546447 + .0849719*ii, (- .163197 +                   |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     .856396*ii)x11*x32*x53 + (- .12002 + .6028*ii)x11*x32 + (- .0789951 +   |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     .294668*ii)x11*x53 + (.494277 + .293229*ii)x32*x53 + (- .132923 +       |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     .073211*ii)x11 + (.0697774 - .0225692*ii)x32 + (.268987 + .156267*ii)x53|
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     - .120066 - .217474*ii, (- .0647381 - .530494*ii)x11*x32*x53 + (.244667 |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     + .0388226*ii)x11*x32 + (- .071549 - .251294*ii)x11*x53 + (- .00247907 +|
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     .0248108*ii)x32*x53 + (.21949 - .0809399*ii)x11 + (- .0359926 -         |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     .0103534*ii)x32 + (- .363356 + .0515771*ii)x53 + .00303043 - .137416*ii,|
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     (.124577 + .254012*ii)x11*x32*x53 + (.430422 + .0947952*ii)x11*x32 +    |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     (.432935 - .140885*ii)x11*x53 + (- .153941 - .0356372*ii)x32*x53 +      |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     (.6925 - .164863*ii)x11 + (- .0791601 - .0121276*ii)x32 + (.130397 -    |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     .488438*ii)x53 + .0622165 - .376375*ii}, {{-.222837+.0578575*ii,        |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     -.283529-1.74632*ii, -.170237+.574751*ii}, {.313108+.0647815*ii,        |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     1.55934+3.57986*ii, -.119638-.243962*ii}}, {| -.408248+3.70074e-17ii    |
|                                                 | -.254463-.319242ii        |
|                                                 | -.379006-.151728ii        |
|                                                 | .148242-.380383ii         |
|                                                 | -.400969+.0767495ii       |
|                                                 | .34486-.218491ii          |
|     ------------------------------------------------------------------------|
|     .295782-.557811ii   -.123338-.130106ii  -.443403-.43011ii               |
|     -.277722-.0337416ii -.15377+.281621ii   .287922-.0364758ii              |
|     -.310281+.0181191ii -.414435+.0695857ii .155757-.124855ii               |
|     -.154992-.218188ii  .665036+.134935ii   -.224407-.00485309ii            |
|     .437341-.302059ii   .157632+.2603ii     .322701+.575512ii               |
|     .0124012-.268702ii  -.310116+.197611ii  .0692093-.0616366ii             |
|     ------------------------------------------------------------------------|
|     .101776-.0720625ii  -.0339506+.0651831ii |}, | 1  1  1  1  1  1 |, {|   |
|     .171133-.455241ii   -.0427233+.574042ii  |   | -1 -1 -1 -1 -1 0 |   |   |
|     -.370187+.597805ii  -.149512-.059328ii   |   | 1  1  1  1  0  0 |   |   |
|     -.131206+.363686ii  -.0506159+.314321ii  |   | -1 -1 -1 0  0  0 |   |   |
|     -.0364793+.110345ii .0844233-.0473268ii  |   | 1  1  0  0  0  0 |   |   |
|     .209126+.2163ii     .724911-.033938ii    |   | -1 0  0  0  0  0 |   |   |
|     ------------------------------------------------------------------------|
|     -.222837+.0578575ii 0                  0                  |, |          |
|     1                   0                  0                  |  |          |
|     0                   -.283529-1.74632ii 0                  |  |          |
|     0                   1                  0                  |  |          |
|     0                   0                  -.170237+.574751ii |  |          |
|     0                   0                  1                  |  |          |
|     ------------------------------------------------------------------------|
|     .313108+.0647815ii 0                 0                  |})             |
|     1                  0                 0                  |               |
|     0                  1.55934+3.57986ii 0                  |               |
|     0                  1                 0                  |               |
|     0                  0                 -.119638-.243962ii |               |
|     0                  0                 1                  |               |
|                                                                             |
|o2 : Sequence                                                                |
|-----------------------------------------------------------------------------|
|p, s)                                                                        |
+-----------------------------------------------------------------------------+
|i3 : vars(R)                                                                 |
|                                                                             |
|o3 = | x11 x32 x53 |                                                         |
|                                                                             |
|             1       3                                                       |
|o3 : Matrix R  <--- R                                                        |
+-----------------------------------------------------------------------------+
|i4 : peek sols                                                               |
|                                                                             |
|o4 = {Point{cache => CacheTable{...3...}                                     |
|            Coordinates => {-.222837+.0578575*ii, -.283529-1.74632*ii,       |
|     ------------------------------------------------------------------------|
|                         }, Point{cache => CacheTable{...3...}               |
|     -.170237+.574751*ii}         Coordinates => {.313108+.0647815*ii,       |
|     ------------------------------------------------------------------------|
|                                             }}                              |
|     1.55934+3.57986*ii, -.119638-.243962*ii}                                |
+-----------------------------------------------------------------------------+
|i5 : peek solutionPlanes                                                     |
|                                                                             |
|o5 = {Matrix{cache => CacheTable{}                                           |
|             RawMatrix => -.222837+.0578575i 0                               |
|                          1                  0                               |
|                          0                  -.283529-1.74632i               |
|                          0                  1                               |
|                          0                  0                               |
|                          0                  0                               |
|                                                                             |
|             ring => CC                                                      |
|                       53                                                    |
|                           3                                                 |
|             source => CC                                                    |
|                         53                                                  |
|                           6                                                 |
|             target => CC                                                    |
|                         53                                                  |
|-----------------------------------------------------------------------------|
|                  }, Matrix{cache => CacheTable{}                            |
|0                           RawMatrix => .313108+.0647815i 0                 |
|0                                        1                 0                 |
|0                                        0                 1.55934+3.57986i  |
|0                                        0                 1                 |
|-.170237+.574751i                        0                 0                 |
|1                                        0                 0                 |
|                                                                             |
|                            ring => CC                                       |
|                                      53                                     |
|                                          3                                  |
|                            source => CC                                     |
|                                        53                                   |
|                                          6                                  |
|                            target => CC                                     |
|                                        53                                   |
|-----------------------------------------------------------------------------|
|                  }}                                                         |
|0                                                                            |
|0                                                                            |
|0                                                                            |
|0                                                                            |
|-.119638-.243962i                                                            |
|1                                                                            |
+-----------------------------------------------------------------------------+

Ways to use parseTriplet :
==========================

  * "parseTriplet(String,String,String)"

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

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

partition2bracket -- dictionary between different notations for Schubert conditions.
************************************************************************************

Synopsis
========

  * Usage:
        b = partition2bracket(l,k,n)
  * Inputs:
      * l, a list (Macaulay2Doc), partition representing a Schubert
        condition
      * k, an integer (Macaulay2Doc),
      * n, an integer (Macaulay2Doc), $k$ and $n$ represent the
        Grassmannian $Gr(k,n)$
  * Outputs:
      * b, a list (Macaulay2Doc), the corresponding bracket

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

A Schubert condition in the Grassmannian $Gr(k,n)$ is encoded either by a
partition $l$ or by a bracket $b$.

A partition is a weakly decreasing list of at most $k$ nonnegative integers
less than or equal to $n-k$.  It may be padded with zeroes to be of length $k$.

A bracket is a strictly increasing list of length $k$ of positive integers
between $1$ and $n$.

This function writes a partition as a bracket. They are related as follows
$b_{k+1-i}=n-i-l_i$, for $i=1,...,k$.

+-----------------------------+
|i1 : l = {2,1};              |
+-----------------------------+
|i2 : k = 2;                  |
+-----------------------------+
|i3 : n = 4;                  |
+-----------------------------+
|i4 : partition2bracket(l,k,n)|
|                             |
|o4 = {1, 3}                  |
|                             |
|o4 : List                    |
+-----------------------------+
|i5 : k = 3;                  |
+-----------------------------+
|i6 : n = 6;                  |
+-----------------------------+
|i7 : partition2bracket(l,k,n)|
|                             |
|o7 = {2, 4, 6}               |
|                             |
|o7 : List                    |
+-----------------------------+

See also
========

  * bracket2partition -- dictionary between different
    notations for Schubert conditions.

Ways to use partition2bracket :
===============================

  * "partition2bracket(List,ZZ,ZZ)"

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

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

PieriHomotopies -- runs the Pieri homotopies to solve a general hypersurface problem
************************************************************************************

Synopsis
========

  * Usage:
        (inplanes, outplanes) = PieriHomotopies(m,p)
  * Inputs:
      * m, an integer (Macaulay2Doc), the dimension of the input
        planes
      * p, an integer (Macaulay2Doc), the dimension of the output
        planes
  * Optional inputs (Macaulay2Doc),:
      * Verbose, =>
        ..., default value false, request verbose feedback
  * Outputs:
      * t, a list (Macaulay2Doc), list of lists, the first list
        contains the input m-planes, generated at random; the second list holds
        the output p-planes, p-planes, which meet the input m-planes

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

This solves the Schubert intersection problem on $Gr(p,m+p)$ of the $p$-planes
that meet $m\cdot p$ general $m$-planes. It is a simple Schubert problem
$l_1,\dotsc,l_{mp}$, where each Schubert condition $l_i$ has codimension 1.
This is less general than solveSimpleSchubert,
which allows up to two of the $\ell_i$ to not have codimension 1

The example below computes the two lines that meet four given lines in
projective 3-space.

To verify the first intersection condition, we concatenate the first input
plane with the first output plane. The determinant of the concatenated matrix
should have real and imaginary parts of the same magnitude as the machine
precision.

+-----------------------------------------------------------------------------+
|i1 : (ipt, otp) := PieriHomotopies(2,2);                                     |
+-----------------------------------------------------------------------------+
|i2 : print ipt                                                               |
|{| -.5               -.156693-.47535ii   |, | -.5                            |
| | .201236-.457716ii -.488637+.0159579ii |  | .498614+.0372063ii             |
| | .462573+.189805ii .146037-.49664ii    |  | -.46663+.179601ii              |
| | .238586-.439405ii .473754+.134341ii   |  | .412393-.282723ii              |
|-----------------------------------------------------------------------------|
|-.393934-.433592ii |, | -.5                 .512862+.452276ii  |, |          |
|-.276014+.153901ii |  | .144239+.478743ii   -.318615-.207177ii |  |          |
|.280441-.151808ii  |  | -.0697009+.495118ii -.260024+.275036ii |  |          |
|-.213211-.640151ii |  | .400527-.299296ii   .388872-.305781ii  |  |          |
|-----------------------------------------------------------------------------|
|-.5                .0279051+.376076ii  |}                                    |
|-.177981-.46725ii  -.429875+.0533154ii |                                     |
|-.232842-.442475ii .259034+.251049ii   |                                     |
|-.294096-.404361ii .396186-.618923ii   |                                     |
+-----------------------------------------------------------------------------+
|i3 : print otp                                                               |
|{| 1                   0                 |, | 1                              |
| | -.237282-.112854ii  -1.5372-1.19825ii |  | -.193856+.191757ii             |
| | -.0761311+.302235ii 1                 |  | .841397+.00470807ii            |
| | 0                   1.419-3.27969ii   |  | 0                              |
|-----------------------------------------------------------------------------|
|0                  |}                                                        |
|1.26877+.351218ii  |                                                         |
|1                  |                                                         |
|-.324549-1.86455ii |                                                         |
+-----------------------------------------------------------------------------+
|i4 : in0 = ipt_0                                                             |
|                                                                             |
|o4 = | -.5               -.156693-.47535ii   |                               |
|     | .201236-.457716ii -.488637+.0159579ii |                               |
|     | .462573+.189805ii .146037-.49664ii    |                               |
|     | .238586-.439405ii .473754+.134341ii   |                               |
|                                                                             |
|                4          2                                                 |
|o4 : Matrix CC    <--- CC                                                    |
|              53         53                                                  |
+-----------------------------------------------------------------------------+
|i5 : out0 = otp_0                                                            |
|                                                                             |
|o5 = | 1                   0                 |                               |
|     | -.237282-.112854ii  -1.5372-1.19825ii |                               |
|     | -.0761311+.302235ii 1                 |                               |
|     | 0                   1.419-3.27969ii   |                               |
|                                                                             |
|                4          2                                                 |
|o5 : Matrix CC    <--- CC                                                    |
|              53         53                                                  |
+-----------------------------------------------------------------------------+
|i6 : m = in0|out0                                                            |
|                                                                             |
|o6 = | -.5               -.156693-.47535ii   1                               |
|     | .201236-.457716ii -.488637+.0159579ii -.237282-.112854ii              |
|     | .462573+.189805ii .146037-.49664ii    -.0761311+.302235ii             |
|     | .238586-.439405ii .473754+.134341ii   0                               |
|     ------------------------------------------------------------------------|
|     0                 |                                                     |
|     -1.5372-1.19825ii |                                                     |
|     1                 |                                                     |
|     1.419-3.27969ii   |                                                     |
|                                                                             |
|                4          4                                                 |
|o6 : Matrix CC    <--- CC                                                    |
|              53         53                                                  |
+-----------------------------------------------------------------------------+
|i7 : det m                                                                   |
|                                                                             |
|o7 = 2.10795754464218e-15-2.69974970552918e-15*ii                            |
|                                                                             |
|o7 : CC (of precision 53)                                                    |
+-----------------------------------------------------------------------------+

Ways to use PieriHomotopies :
=============================

  * "PieriHomotopies(ZZ,ZZ)"

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

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

PieriRootCount -- the number of solutions to a generic Pieri problem
********************************************************************

Synopsis
========

  * Usage:
        r = PieriRootCount(m,p,q)
  * Inputs:
      * m, an integer (Macaulay2Doc), the dimension of the input
        planes
      * p, an integer (Macaulay2Doc), the dimension of the output
        planes
      * q, an integer (Macaulay2Doc), the degree of the solution
        curves producing p-planes
  * Optional inputs (Macaulay2Doc),:
      * Verbose, =>
        ..., default value false, request verbose feedback
  * Outputs:
      * r, an integer (Macaulay2Doc), the number of curves of the
        degree $q$ in the Grassmannian $Gr(p,m+p)$ which produce $p$-planes
        that meet $m\cdot p + q\cdot (m+p)$ generic $m$-planes at given general
        interpolation points. This is a quantum intersection number

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

The example below computes the number of linear curves which produce 2-planes
that meet 2*3 + 1*(2 + 3) = eleven generic 3-planes at some eleven distinct
interpolation points.

+--------------------------------+
|i1 : r := PieriRootCount(3,2,1);|
+--------------------------------+
|i2 : print r                    |
|55                              |
+--------------------------------+

Ways to use PieriRootCount :
============================

  * "PieriRootCount(ZZ,ZZ,ZZ)"

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

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

PieriRootCount(...,Verbose=>...) -- request verbose feedback
************************************************************

Further information
===================

  * Default value: false (Macaulay2Doc),
  * Function: PieriRootCount, -- the number of solutions
    to a generic Pieri problem
  * Option key: Verbose (Macaulay2Doc), -- request verbose
    feedback

Functions with optional argument named Verbose :
================================================

  * "check(...,Verbose=>...)" -- see check (Macaulay2Doc), --
    perform tests of a package
  * "checkDegrees(...,Verbose=>...)" -- see checkDegrees (Isomorphism),
    -- compares the degrees of generators of two
    modules
  * "copyDirectory(...,Verbose=>...)" -- see
    copyDirectory(String,String) (Macaulay2Doc),
  * "copyFile(...,Verbose=>...)" -- see copyFile(String,String) (Macaulay2Doc),
  * "findProgram(...,Verbose=>...)" -- see findProgram (Macaulay2Doc),
    -- load external program
  * "installPackage(...,Verbose=>...)" -- see installPackage (Macaulay2Doc),
    -- load and install a package and its
    documentation
  * "isIsomorphic(...,Verbose=>...)" -- see isIsomorphic (Isomorphism),
    -- Probabilistic test for isomorphism of modules
  * "moveFile(...,Verbose=>...)" -- see moveFile(String,String) (Macaulay2Doc),
  * "LRcheater(...,Verbose=>...)"
  * "LRrule(...,Verbose=>...)"
  * "LRtriple(...,Verbose=>...)"
  * "parseTriplet(...,Verbose=>...)"
  * "PieriHomotopies(...,Verbose=>...)"
  * PieriRootCount(...,Verbose=>...)
    -- request verbose
    feedback
  * "runProgram(...,Verbose=>...)" -- see runProgram (Macaulay2Doc),
    -- run an external program
  * "symlinkDirectory(...,Verbose=>...)" -- see
    symlinkDirectory(String,String) (Macaulay2Doc),
    -- make symbolic links
    for all files in a directory tree

printStatistics -- summary statistics (used by developers)
**********************************************************

Synopsis
========

  * Usage:
        printStatistics()

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

+-----------------------------------------------------------------------------+
|i1 : k = 3;                                                                  |
+-----------------------------------------------------------------------------+
|i2 : n = 6;                                                                  |
+-----------------------------------------------------------------------------+
|i3 : SchPblm = {                                                             |
|         ({2,1}, random(CC^6,CC^6)),                                         |
|         ({2,1}, random(CC^6,CC^6)),                                         |
|         ({2,1}, random(CC^6,CC^6))                                          |
|         };                                                                  |
+-----------------------------------------------------------------------------+
|i4 : resetStatistics()                                                       |
+-----------------------------------------------------------------------------+
|i5 : solveSchubertProblem(SchPblm, k,n)                                      |
|                                                                             |
|o5 = {| -.973546-.443329ii  -.193482-.957391ii -.460977-.267623ii  |, |      |
|      | .153343-.291038ii   .339479-1.30008ii  -.577303-.171329ii  |  |      |
|      | .326239-.770744ii   .120186-1.46205ii  -.0769985-.323186ii |  |      |
|      | -.451322-.514227ii  -.144874-.987789ii -.589493-.209825ii  |  |      |
|      | -.0525679-.692383ii .364061-.704785ii  -.325325-.185011ii  |  |      |
|      | -.942864-.594173ii  -.826353-.203654ii -.236865+.691374ii  |  |      |
|     ------------------------------------------------------------------------|
|     -5.47422+1.18674ii -.912706-1.64344ii -.590144+.126046ii |}             |
|     -2.80395-.714508ii -.793467-2.20255ii -.016225+.340982ii |              |
|     -2.29873-2.34724ii -.905617-2.59114ii .0951404+.355536ii |              |
|     -3.36313+2.14592ii -.703202-1.58202ii -.375349+.205204ii |              |
|     -3.91243-.845457ii -.528411-.900447ii -.187047+.545512ii |              |
|     -4.19554+1.93172ii -1.11528-.480829ii .19859+1.24706ii   |              |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : printStatistics()                                                       |
|# moves of type {} = 2                                                       |
|# moves of type {0, 0, 0} = 3                                                |
|# moves of type {0, 1, 0} = 2                                                |
|# moves of type {0, 2, 0} = 10                                               |
|# moves of type {1, 0, 0} = 1                                                |
|# moves of type {1, 1, 0} = 3                                                |
|# moves of type {1, 1, 1} = 3                                                |
|# moves of type {1, 2, 0} = 6                                                |
|# moves of type {2, 0, 0} = 3                                                |
|# moves of type {2, 1, 0} = 1                                                |
|# moves of type {2, 2, 0} = 12                                               |
|tracking time = .0627298                                                     |
+-----------------------------------------------------------------------------+

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

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

randomSchubertProblemInstance -- returns a random instance of a given Schubert problem
**************************************************************************************

Synopsis
========

  * Usage:
        randomSchubertProblemInstance(conditions,k,n)
  * Inputs:
      * conditions, a list (Macaulay2Doc), which is a list of
        Schubert conditions that are either all partitions or all brackets (see
        bracket2partition, for details)
      * k, an integer (Macaulay2Doc),
      * n, an integer (Macaulay2Doc), $k$ and $n$ define the
        Grassmannian $Gr(k,n)$ of $k$-planes in $n$-space
  * Optional inputs (Macaulay2Doc),:
      * Strategy,
        => ..., default value "unit circle", strategy for creating
        a random matrix representing a flag
  * Outputs:
      * a list (Macaulay2Doc), random instance of the Schubert
        problem, which is a list of pairs of the form (condition,flag)

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

This first verifies that the conditions are either all partitions or all
brackets, and that they form a Schubert problem on $Gr(k,n)$.

Then it creates a list of random square invertible matrices that represent
flags for the Schubert problem.

For instance, consider the problem of four lines, which is given by 4
partitions {1}$^4$ in $Gr(2,4)$

+-----------------------------------------------------------------------------+
|i1 : randomSchubertProblemInstance({{1},{1},{1},{1}},2,4)                    |
|                                                                             |
|o1 = {({1}, | .781262-.624203ii  -.462954-.886382ii -.272832+.962062ii       |
|            | .9868+.161945ii    -.219207-.975678ii .778029-.628229ii        |
|            | -.971549+.236839ii .157598-.987503ii  .841103-.540875ii        |
|            | .893324+.449414ii  .360485-.932765ii  -.651048+.759036ii       |
|     ------------------------------------------------------------------------|
|     -.670948-.741504ii |), ({1}, | .696205+.717843ii  -.0281556+.999604ii   |
|     .118767+.992922ii  |         | -.58234+.812945ii  -.924052-.382267ii    |
|     -.396553+.918012ii |         | .486335-.873772ii  -.970803-.23988ii     |
|     -.272372-.962192ii |         | -.783999-.620762ii .577597-.816322ii     |
|     ------------------------------------------------------------------------|
|     -.0562287-.998418ii .776937+.629579ii  |), ({1}, | -.746312-.665596ii   |
|     .023444+.999725ii   .570649+.821194ii  |         | -.936289-.351232ii   |
|     .701149-.713015ii   -.863646+.504099ii |         | -.164243+.98642ii    |
|     .357971+.933733ii   -.820726+.571321ii |         | .85817-.513365ii     |
|     ------------------------------------------------------------------------|
|     .995687+.092774ii .168661+.985674ii  -.765803+.643076ii |), ({1}, |     |
|     .701342-.712825ii -.286823-.957983ii -.415126-.909764ii |         |     |
|     -.78761-.616174ii .976163-.21704ii   -.416188-.909278ii |         |     |
|     .759918-.650019ii .482783+.87574ii   .975922-.218119ii  |         |     |
|     ------------------------------------------------------------------------|
|     .918399+.395655ii  .719639-.694348ii  .9772+.212322ii                   |
|     .58629+.810101ii   -.554833-.831962ii .454813+.890587ii                 |
|     -.590887+.806754ii -.726792+.686857ii .0800129+.996794ii                |
|     -.939129+.343564ii -.616052-.787706ii .339065+.940763ii                 |
|     ------------------------------------------------------------------------|
|     -.998741-.0501734ii |)}                                                 |
|     -.698649-.715464ii  |                                                   |
|     .742918+.669382ii   |                                                   |
|     -.99319-.116506ii   |                                                   |
|                                                                             |
|o1 : List                                                                    |
+-----------------------------------------------------------------------------+

the same problem but using brackets instead of partitions

+-----------------------------------------------------------------------------+
|i2 : randomSchubertProblemInstance({{2,4},{2,4},{2,4},{2,4}},2,4)            |
|                                                                             |
|o2 = {({2, 4}, | .996754-.0805092ii -.909393-.415938ii .398424+.917201ii     |
|               | -.531694+.846937ii .92457+.381011ii   -.976915+.213627ii    |
|               | .51095+.859611ii   -.227376-.973807ii .842765-.538281ii     |
|               | -.341238+.939977ii -.110622-.993863ii -.923063-.384649ii    |
|     ------------------------------------------------------------------------|
|     -.688353+.725376ii |), ({2, 4}, | -.991977+.126418ii .398109-.917338ii  |
|     -.81898+.573823ii  |            | .91893+.394421ii   -.210222+.977654ii |
|     -.915156-.403101ii |            | -.834955-.550318ii .491643-.870797ii  |
|     -.684587-.728932ii |            | -.978842+.204616ii .0976385-.995222ii |
|     ------------------------------------------------------------------------|
|     .989783-.142579ii    .930733+.365699ii  |), ({2, 4}, |                  |
|     .990088-.140449ii    .233835+.972276ii  |            |                  |
|     -.999969-.00781125ii .565772+.824562ii  |            |                  |
|     -.344326+.93885ii    -.974074-.226228ii |            |                  |
|     ------------------------------------------------------------------------|
|     .276727+.960949ii  -.166675+.986012ii .824149+.566373ii                 |
|     .74405-.668124ii   .936252-.351329ii  .869663+.493645ii                 |
|     -.191573+.981478ii -.987864+.155324ii .68453+.728985ii                  |
|     .476077+.879404ii  -.535925+.844266ii .415186-.909737ii                 |
|     ------------------------------------------------------------------------|
|     -.788618-.614883ii |), ({2, 4}, | .109319-.994007ii  .560285+.8283ii    |
|     .794218+.607632ii  |            | .984107-.177574ii  .0000532609+1ii    |
|     -.990213-.139564ii |            | -.764815-.64425ii  -.64519-.764022ii  |
|     .194585-.980886ii  |            | -.129853+.991533ii .889567+.456804ii  |
|     ------------------------------------------------------------------------|
|     .990856+.13492ii   -.211093+.977466ii |)}                               |
|     .978795+.20484ii   .241807+.970324ii  |                                 |
|     .93104+.364917ii   .923802+.382872ii  |                                 |
|     -.872433-.488734ii -.636591-.771201ii |                                 |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+

Caveat
======

The output consists of random numerical matrices that are assumed invertible.
The code does not check invertibility.

See also
========

  * solveSchubertProblem -- uses
    Littlewood-Richardson homotopy algorithm to solve a Schubert problem
  * partition2bracket -- dictionary between different
    notations for Schubert conditions.
  * bracket2partition -- dictionary between different
    notations for Schubert conditions.

Ways to use randomSchubertProblemInstance :
===========================================

  * "randomSchubertProblemInstance(List,ZZ,ZZ)"

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

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

randomSchubertProblemInstance(...,Strategy=>...) -- strategy for creating a random matrix representing a flag
*************************************************************************************************************

Synopsis
========

  * Usage:
        randomSchubertProblemInstance(...,Strategy=>S)
  * Inputs:
      * S, a string (Macaulay2Doc), "unit circle" entries are
        random unit complex numbers [default] "unitary" uses the Random Unitary
        Matrix from NAG4M2.

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

Determines how a random matrix for a random flag is created.

Further information
===================

  * Default value: unit circle
  * Function: randomSchubertProblemInstance,
    -- returns a random instance of a given
    Schubert problem
  * Option key: Strategy (Macaulay2Doc), -- an optional argument

Functions with optional argument named Strategy :
=================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * "annihilator(...,Strategy=>...)" -- see annihilator (Saturation),
    -- the annihilator ideal
  * "associatedPrimes(...,Strategy=>...)" -- see associatedPrimes (PrimaryDecomposition),
    -- find associated primes
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hermite(...,Strategy=>...) (missing documentation)
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "idealizer(...,Strategy=>...)" -- see idealizer (IntegralClosure),
    -- compute Hom(I,I) as a quotient ring
  * integralClosure(...,Strategy=>...) (IntegralClosure),
    --
    control the algorithm used
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersectInP(...,Strategy=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "isPrimary(...,Strategy=>...)" -- see isPrimary (PrimaryDecomposition),
    -- determine whether a submodule is
    primary
  * "isPrime(Ideal,Strategy=>...)" -- see isPrime(Ideal) (MinimalPrimes),
    -- whether an ideal is prime
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * "localize(...,Strategy=>...)" -- see localize (PrimaryDecomposition),
    -- localize an ideal at a prime ideal
  * LRnumber(...,Strategy=>...)
    -- strategy for computing
    the number of solutions to a Schubert problem
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * "decompose(Ideal,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "minimalPrimes(...,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "primaryComponent(...,Strategy=>...)" -- see primaryComponent (PrimaryDecomposition),
    -- find a primary component
    corresponding to an associated prime
  * pushForward(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (Saturation)
  * "radical(...,Strategy=>...)" -- see radical (MinimalPrimes),
    -- the radical of an ideal
  * "radicalContainment(...,Strategy=>...)" -- see radicalContainment (MinimalPrimes),
    -- whether an element is contained in
    the radical of an ideal
  * randomSchubertProblemInstance(...,Strategy=>...),
    --
    strategy for creating a random matrix representing a flag
  * "analyticSpread(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "distinguished(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isLinearType(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isReduction(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "minimalReduction(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "multiplicity(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "normalCone(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "reesAlgebra(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * reesIdeal(...,Strategy=>...) (ReesAlgebra)
    -- Choose a
    strategy for the saturation step
  * "specialFiber(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "specialFiberIdeal(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "regSeqInIdeal(...,Strategy=>...)" -- see regSeqInIdeal (PrimaryDecomposition),
    -- a regular sequence contained in an
    ideal
  * resolution(...,Strategy=>...) (Macaulay2Doc)
  * saturate(...,Strategy=>...) (Saturation)
  * "primaryDecomposition(...,Strategy=>...)" -- see strategies for computing primary decomposition (PrimaryDecomposition),
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix
  * "tangentCone(...,Strategy=>...)" -- see tangentCone(Ideal) (TangentCone),

RandomSeed -- seed for the random number generators.
****************************************************

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

To avoid singularities during complex path following, the homotopy methods use
a random constant. The flags generated in LRtriple, also depend
on the values generated by the random number generator. Fixing the value of
RandomSeed leads to reproducible runs.

Functions with optional argument named RandomSeed :
===================================================

  * LRtriple(...,RandomSeed=>...)
    -- option to set the seed
    of the random number generators.

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

The object RandomSeed, is a symbol (Macaulay2Doc).

setVerboseLevel -- set different levels of information printed on screen
************************************************************************

Synopsis
========

  * Usage:
        setVerboseLevel n
  * Inputs:
      * n, see ZZ (Macaulay2Doc), takes values 0,1,2, or greater
  * Consequences:
      * Prints information on the screen depending on the value of n

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

The function displays different levels of information on the screen:

  * 0 = no extra information displayed [default]
  * 1 = print the progress information and time the main process
  * 2 = besides the information of level 1, it also displays the checkerboard
    steps

Consider the problem of four lines with respect to random flags

+-----------------------------------------------------------------------------+
|i1 : SchPblm = randomSchubertProblemInstance ({{1},{1},{1},{1}},2,4)         |
|                                                                             |
|o1 = {({1}, | .781262-.624203ii  -.462954-.886382ii -.272832+.962062ii       |
|            | .9868+.161945ii    -.219207-.975678ii .778029-.628229ii        |
|            | -.971549+.236839ii .157598-.987503ii  .841103-.540875ii        |
|            | .893324+.449414ii  .360485-.932765ii  -.651048+.759036ii       |
|     ------------------------------------------------------------------------|
|     -.670948-.741504ii |), ({1}, | .696205+.717843ii  -.0281556+.999604ii   |
|     .118767+.992922ii  |         | -.58234+.812945ii  -.924052-.382267ii    |
|     -.396553+.918012ii |         | .486335-.873772ii  -.970803-.23988ii     |
|     -.272372-.962192ii |         | -.783999-.620762ii .577597-.816322ii     |
|     ------------------------------------------------------------------------|
|     -.0562287-.998418ii .776937+.629579ii  |), ({1}, | -.746312-.665596ii   |
|     .023444+.999725ii   .570649+.821194ii  |         | -.936289-.351232ii   |
|     .701149-.713015ii   -.863646+.504099ii |         | -.164243+.98642ii    |
|     .357971+.933733ii   -.820726+.571321ii |         | .85817-.513365ii     |
|     ------------------------------------------------------------------------|
|     .995687+.092774ii .168661+.985674ii  -.765803+.643076ii |), ({1}, |     |
|     .701342-.712825ii -.286823-.957983ii -.415126-.909764ii |         |     |
|     -.78761-.616174ii .976163-.21704ii   -.416188-.909278ii |         |     |
|     .759918-.650019ii .482783+.87574ii   .975922-.218119ii  |         |     |
|     ------------------------------------------------------------------------|
|     .918399+.395655ii  .719639-.694348ii  .9772+.212322ii                   |
|     .58629+.810101ii   -.554833-.831962ii .454813+.890587ii                 |
|     -.590887+.806754ii -.726792+.686857ii .0800129+.996794ii                |
|     -.939129+.343564ii -.616052-.787706ii .339065+.940763ii                 |
|     ------------------------------------------------------------------------|
|     -.998741-.0501734ii |)}                                                 |
|     -.698649-.715464ii  |                                                   |
|     .742918+.669382ii   |                                                   |
|     -.99319-.116506ii   |                                                   |
|                                                                             |
|o1 : List                                                                    |
+-----------------------------------------------------------------------------+
|i2 : setVerboseLevel 0;                                                      |
+-----------------------------------------------------------------------------+
|i3 : S = solveSchubertProblem(SchPblm,2,4)                                   |
|                                                                             |
|o3 = {| -1.65573-.600637ii .0201935+.0437095ii   |, | -.154703+.175591ii     |
|      | -1.23037-1.66989ii -.0308057-.00120618ii |  | -.801221-.0354303ii    |
|      | 1.35971-.743988ii  -.0713133-.049047ii   |  | .325581-2.08048ii      |
|      | -.397038-1.8974ii  .0102261-.024397ii    |  | -.475895-.209388ii     |
|     ------------------------------------------------------------------------|
|     .0376857+.0683239ii   |}                                                |
|     -.00368075+.0317504ii |                                                 |
|     -.0350432-.250817ii   |                                                 |
|     -.0336427+.0141017ii  |                                                 |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : assert all(S,s->checkIncidenceSolution(s,SchPblm))                      |
+-----------------------------------------------------------------------------+
|i5 : setVerboseLevel 1;                                                      |
+-----------------------------------------------------------------------------+
|i6 : S = solveSchubertProblem(SchPblm,2,4)                                   |
|-- playCheckers                                                              |
|-- cpu time = .00494953                                                      |
|-- making a recursive call to resolveNode                                    |
|-- playCheckers                                                              |
|-- cpu time = .00228437                                                      |
|-- making a recursive call to resolveNode                                    |
|-- playCheckers                                                              |
|-- cpu time = .000274343                                                     |
|resolveNode reached node of no remaining conditions                          |
|-- time to make equations: .00390117                                         |
|Setup time: 0                                                                |
|Computing time:0                                                             |
| -- trackHomotopy time = .0136096 sec. for [{0, 1, 2, 3}, {0, infinity, 2, in|
|-- time of performing one checker move: .0196087                             |
|-- time of performing one checker move: .0010252                             |
|-- time of performing one checker move: .00101623                            |
|-- time to make equations: .00493436                                         |
|Setup time: 0                                                                |
|Computing time:0                                                             |
| -- trackHomotopy time = .00615856 sec. for [{1, 2, 3, 0}, {1, infinity, infi|
|-- time of performing one checker move: .0152368                             |
|-- time to make equations: .00436537                                         |
|Setup time: 0                                                                |
|Computing time:0                                                             |
| -- trackHomotopy time = .00607117 sec. for [{1, 3, 2, 0}, {1, infinity, infi|
|-- time of performing one checker move: .0145254                             |
|-- time to make equations: .0044331                                          |
|Setup time: 0                                                                |
|Computing time:0                                                             |
| -- trackHomotopy time = .0143777 sec. for [{2, 3, 1, 0}, {2, infinity, infin|
|-- time of performing one checker move: .0221031                             |
|-- time to make equations: .0105845                                          |
|Setup time: 0                                                                |
|Computing time:0                                                             |
| -- trackHomotopy time = .00788359 sec. for [{0, 1, 2, 3}, {infinity, 1, 2, i|
|-- time of performing one checker move: .0230352                             |
|-- time to make equations: .0101357                                          |
|Setup time: 0                                                                |
|Computing time:0                                                             |
| -- trackHomotopy time = .00744606 sec. for [{0, 1, 3, 2}, {infinity, 1, infi|
|-- time of performing one checker move: .0221374                             |
|-- time of performing one checker move: .000947422                           |
|-- time of performing one checker move: .000955539                           |
|-- time to make equations: .0102118                                          |
|Setup time: 0                                                                |
|Computing time:0                                                             |
| -- trackHomotopy time = .00708272 sec. for [{1, 3, 2, 0}, {infinity, 3, infi|
|-- time of performing one checker move: .0291536                             |
|-- making a recursive call to resolveNode                                    |
|-- playCheckers                                                              |
|-- cpu time = .00277507                                                      |
|-- making a recursive call to resolveNode                                    |
|-- playCheckers                                                              |
|-- cpu time = .000321946                                                     |
|resolveNode reached node of no remaining conditions                          |
|-- time to make equations: .00393774                                         |
|Setup time: 0                                                                |
|Computing time:0                                                             |
| -- trackHomotopy time = .00502202 sec. for [{0, 1, 2, 3}, {0, infinity, 2, i|
|-- time of performing one checker move: .0123765                             |
|-- time of performing one checker move: .000840275                           |
|-- time to make equations: .0113042                                          |
|Setup time: 0                                                                |
|Computing time:0                                                             |
| -- trackHomotopy time = .00574352 sec. for [{0, 2, 3, 1}, {0, infinity, infi|
|-- time of performing one checker move: .021032                              |
|-- time of performing one checker move: .000887347                           |
|-- time of performing one checker move: .000689267                           |
|-- time of performing one checker move: .000872269                           |
|-- time of performing one checker move: .000953705                           |
|-- time of performing one checker move: .000664042                           |
|-- time of performing one checker move: .000883894                           |
|-- time of performing one checker move: .000898403                           |
|-- time to make equations: .0085071                                          |
|Setup time: 0                                                                |
|Computing time:0                                                             |
| -- trackHomotopy time = .00610873 sec. for [{1, 3, 2, 0}, {1, infinity, infi|
|-- time of performing one checker move: .0182445                             |
|-- time of performing one checker move: .00130729                            |
|                                                                             |
|o6 = {| -1.65573-.600637ii .0201935+.0437095ii   |, | -.154703+.175591ii     |
|      | -1.23037-1.66989ii -.0308057-.00120618ii |  | -.801221-.0354303ii    |
|      | 1.35971-.743988ii  -.0713133-.049047ii   |  | .325581-2.08048ii      |
|      | -.397038-1.8974ii  .0102261-.024397ii    |  | -.475895-.209388ii     |
|     ------------------------------------------------------------------------|
|     .0376857+.0683239ii   |}                                                |
|     -.00368075+.0317504ii |                                                 |
|     -.0350432-.250817ii   |                                                 |
|     -.0336427+.0141017ii  |                                                 |
|                                                                             |
|o6 : List                                                                    |
|-----------------------------------------------------------------------------|
|finity}]                                                                     |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|nity, 2}]                                                                    |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|nity, 2}]                                                                    |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|ity, 1}]                                                                     |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|nfinity}]                                                                    |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|nity, 2}]                                                                    |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|nity, 1}]                                                                    |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|nfinity}]                                                                    |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|nity, 2}]                                                                    |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|nity, 3}]                                                                    |
+-----------------------------------------------------------------------------+
|i7 : assert all(S,s->checkIncidenceSolution(s,SchPblm))                      |
+-----------------------------------------------------------------------------+

See also
========

  * checkIncidenceSolution -- check if a
    solution satisfies an instance of a Schubert problem

Ways to use setVerboseLevel :
=============================

  * "setVerboseLevel(ZZ)"

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

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

solutionsToAffineCoords -- writes solutions in global coords to affine coordinates.
***********************************************************************************

Synopsis
========

  * Usage:
        S' = solutionsToAffineCoords S
  * Inputs:
      * S, a list (Macaulay2Doc), solutions to a Schubert problem
        in global coordinates
  * Outputs:
      * S', a list (Macaulay2Doc), solutions in coordinates of an
        affine patch with an identity in the bottom

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

Takes a list of solutions $s\in Gr(k,n)$ in global coordinates and writes them
as solutions in coordinates of the affine patch that has an identity matrix in
the last $k$ rows.

+-----------------------------------------------------------------------------+
|i1 : Pblm = {                                                                |
|         ({2,1}, random(RR^6,RR^6)),                                         |
|         ({2,1}, random(RR^6,RR^6)),                                         |
|         ({2,1}, random(RR^6,RR^6))                                          |
|         }                                                                   |
|                                                                             |
|o1 = {({2, 1}, | .892712  .89189  .0741835 .741046 .830833 .191734  |), ({2, |
|               | .673395  .231053 .808694  .108386 .538554 .403215  |        |
|               | .29398   .461944 .362835  .348931 .873665 .615911  |        |
|               | .632944  .775187 .706096  .562428 .415912 .0147867 |        |
|               | .0258884 .909047 .127435  .246268 .606588 .223028  |        |
|               | .714827  .314897 .254482  .153346 .848005 .388829  |        |
|     ------------------------------------------------------------------------|
|     1}, | .557119 .96518  .0647412 .174853 .444183 .184779 |), ({2, 1}, |   |
|         | .873708 .681683 .877846  .626892 .644366 .370833 |            |   |
|         | .7037   .914199 .0340514 .350611 .194945 .339222 |            |   |
|         | .681869 .887381 .507989  .379495 .518585 .062212 |            |   |
|         | .276259 .169813 .150294  .237252 .987173 .465736 |            |   |
|         | .605659 .965004 .656391  .116721 .568273 .40273  |            |   |
|     ------------------------------------------------------------------------|
|     .164647 .562839  .0645275 .501243 .205375  .0821679 |)}                 |
|     .713493 .629991  .283709  .154289 .276652  .10394   |                   |
|     .909537 .479826  .977573  .467203 .0958269 .280679  |                   |
|     .566034 .815167  .212436  .765564 .605398  .475179  |                   |
|     .305423 .97723   .592747  .305946 .883549  .130004  |                   |
|     .732358 .0595849 .831802  .53632  .942865  .522285  |                   |
|                                                                             |
|o1 : List                                                                    |
+-----------------------------------------------------------------------------+
|i2 : S = solveSchubertProblem(Pblm, 3,6)                                     |
|                                                                             |
|o2 = {| .362674+1.2327e-16ii   5.87881+2.97425e-14ii .067722-9.01983e-17ii |,|
|      | -.168148+9.29853e-17ii 10.2268+5.44749e-14ii .359604-1.18969e-16ii | |
|      | .287667+4.05941e-17ii  5.41301+2.76829e-14ii .178413-1.05689e-16ii | |
|      | .399967+8.73997e-17ii  10.4365+5.39029e-14ii .172408-1.02452e-16ii | |
|      | .893699+3.57479e-18ii  2.90938+1.5283e-14ii  .127632-3.63809e-17ii | |
|      | -.108865+9.87064e-17ii 5.44614+2.94139e-14ii .099289-9.57795e-17ii | |
|     ------------------------------------------------------------------------|
|     | .675164+1.2692e-15ii  .770431+2.49223e-15ii -.0909566-8.88941e-16ii   |
|     | .0675706+9.5739e-16ii .870501+4.56466e-15ii .150312-1.17248e-15ii     |
|     | .390574+4.17962e-16ii .658364+2.31966e-15ii -.00751668-1.04161e-15ii  |
|     | .621526+8.99879e-16ii 1.17845+4.51673e-15ii -.0078269-1.0097e-15ii    |
|     | .902762+3.68065e-17ii .284467+1.28062e-15ii .0636297-3.58549e-16ii    |
|     | .141356+1.01629e-15ii .394186+2.46471e-15ii -.0692081-9.43946e-16ii   |
|     ------------------------------------------------------------------------|
|     |}                                                                      |
|     |                                                                       |
|     |                                                                       |
|     |                                                                       |
|     |                                                                       |
|     |                                                                       |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : solutionsToAffineCoords S                                               |
|                                                                             |
|o3 = {| 1.17594  -.247384 -1.04186 |, | -.0717886 .515973  1.79675  |}       |
|      | -2.59821 1.69933  5.94898  |  | 1.97727   -.796664 -3.12795 |        |
|      | -.743029 .890962  1.94183  |  | .504284   .067644  .113771  |        |
|      | 1        0        0        |  | 1         0        0        |        |
|      | 0        1        0        |  | 0         1        0        |        |
|      | 0        0        1        |  | 0         0        1        |        |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

Caveat
======

This function may fail if the solutions are not in general position (if they
cannot fit the specific local coordinates) One way to avoid this is by applying
a random linear transformation to the solutions before calling this function

Ways to use solutionsToAffineCoords :
=====================================

  * "solutionsToAffineCoords(List)"

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

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

solveSchubertProblem -- uses Littlewood-Richardson homotopy algorithm to solve a Schubert problem
*************************************************************************************************

Synopsis
========

  * Usage:
        S = solveSchubertProblem(P,k,n)
  * Inputs:
      * P, a list (Macaulay2Doc), Schubert problem given as a list
        of sequences of the form ($l,F$) where $l$ is a partition (a list of
        weakly decreasing integers) and $F$ is a flag ($n \times n$ matrix)
      * k, an integer (Macaulay2Doc),
      * n, an integer (Macaulay2Doc), $k$ and $n$ define the
        Grassmannian $Gr(k,n)$ of $k$-planes in $n$-space
  * Optional inputs (Macaulay2Doc),:
      * LinearAlgebra,
        => ..., default value true, switch between Linear
        Algebra and Parameter Homotopy
  * Outputs:
      * S, a list (Macaulay2Doc), solutions of the Schubert Problem
        given as $n \times k$ matrices

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

Represent a Schubert variety in the Grassmannian $Gr(k,n)$ by a condition $c$
either a partition or a bracket (see  partition2bracket,
for details) and a flag $F$ (given as an $n \times n$
matrix). The codimension of the Schubert variety is $|c|$. A Schubert problem
is a list of Schubert varieties, whose codimension add up to $k(n-k)$, which is
the dimension of the Grassmannian.

The function solveSchubertProblem solves the given instance of the Schubert
problem by the Littlewood-Richardson homotopy. This algorithm uses homotopy
continuation to track solutions of a simpler problem to a general problem
according to the specializations of the geometric Littlewood-Richardson.

This algorithm is described in the paper: Leykin, Martin del Campo, Sottile,
Vakil, Verschelde "Numerical Schubert Calculus via the Littlewood-Richardson
homotopy algorithm". Math. Comp., 90 (2021), 1407-1433.
https://arxiv.org/abs/1802.00984.

For instance, consider the Schubert problem {2,1}$^3$ in $Gr(3,6)$, which has
two solutions

+------------------------------------+
|i1 : k = 3;                         |
+------------------------------------+
|i2 : n = 6;                         |
+------------------------------------+
|i3 : SchPblm = {                    |
|         ({2,1}, random(CC^6,CC^6)),|
|         ({2,1}, random(CC^6,CC^6)),|
|         ({2,1}, random(CC^6,CC^6)) |
|         };                         |
+------------------------------------+

Its solutions to an instance given by random flags

+-----------------------------------------------------------------------------+
|i4 : solveSchubertProblem(SchPblm, k,n)                                      |
|                                                                             |
|o4 = {| -.973546-.443329ii  -.193482-.957391ii -.460977-.267623ii  |, |      |
|      | .153343-.291038ii   .339479-1.30008ii  -.577303-.171329ii  |  |      |
|      | .326239-.770744ii   .120186-1.46205ii  -.0769985-.323186ii |  |      |
|      | -.451322-.514227ii  -.144874-.987789ii -.589493-.209825ii  |  |      |
|      | -.0525679-.692383ii .364061-.704785ii  -.325325-.185011ii  |  |      |
|      | -.942864-.594173ii  -.826353-.203654ii -.236865+.691374ii  |  |      |
|     ------------------------------------------------------------------------|
|     -5.47422+1.18674ii -.912706-1.64344ii -.590144+.126046ii |}             |
|     -2.80395-.714508ii -.793467-2.20255ii -.016225+.340982ii |              |
|     -2.29873-2.34724ii -.905617-2.59114ii .0951404+.355536ii |              |
|     -3.36313+2.14592ii -.703202-1.58202ii -.375349+.205204ii |              |
|     -3.91243-.845457ii -.528411-.900447ii -.187047+.545512ii |              |
|     -4.19554+1.93172ii -1.11528-.480829ii .19859+1.24706ii   |              |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+

Caveat
======

The Schubert conditions must be either all partitions or all brackets.

See also
========

  * solveSimpleSchubert -- uses Pieri homotopy
    algorithm to solve a simple Schubert problem
  * partition2bracket -- dictionary between different
    notations for Schubert conditions.

Ways to use solveSchubertProblem :
==================================

  * "solveSchubertProblem(List,ZZ,ZZ)"

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

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

solveSchubertProblem(...,LinearAlgebra=>...) -- switch between Linear Algebra and Parameter Homotopy
****************************************************************************************************

Synopsis
========

  * Usage:
        solveSchubertProblem(...,LinearAlgebra=>T)
  * Inputs:
      * T, a Boolean value (Macaulay2Doc), true for Linear
        Algebra, false for Parameter Homotopy

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

Chooses the method for glueing solutions from the top of one node (tournament
game) to the leaf of the previous node. When true (default), uses Linear
Algebra, otherwise uses Parameter Homotopies.

Further information
===================

  * Default value: true (Macaulay2Doc),
  * Function: solveSchubertProblem, -- uses
    Littlewood-Richardson homotopy algorithm to solve a Schubert problem
  * Option key: LinearAlgebra (Macaulay2Doc), -- compute a Gröbner
    basis

Caveat
======

Parameter Homotopies are not necessary and usually take longer than simple
Linear Algebra.

Functions with optional argument named LinearAlgebra :
======================================================

  * solveSchubertProblem(...,LinearAlgebra=>...)
    -- switch
    between Linear Algebra and Parameter Homotopy

solveSimpleSchubert -- uses Pieri homotopy algorithm to solve a simple Schubert problem
***************************************************************************************

Synopsis
========

  * Usage:
        S = solveSimpleSchubert(P,k,n)
  * Inputs:
      * P, a list (Macaulay2Doc), Simple Schubert problem given as
        a list of sequences of the form $(l,F)$ where $l$ is a partition (a
        list of weakly decreasing integers) and $F$ is a flag ($n \times n$
        matrix). Necessarily, all partitions except possibly the first two are
        {1}
      * k, an integer (Macaulay2Doc),
      * n, an integer (Macaulay2Doc), $k$ and $n$ define the
        Grassmannian $Gr(k,n)$ of $k$-planes in $n$-space
  * Outputs:
      * S, a list (Macaulay2Doc), solutions of the simple Schubert
        Problem given as $n\times k$ matrices

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

a Schubert variety in the Grassmannian $Gr(k,n)$ is represented by a partition
$l$ (a weakly decreasing list of nonegative integers less than $n-k$) and a
flag $F$ (given as an $n\times n$ matrix). A Schubert problem is a list of
Schubert varieties $(l_1, F_1), \ldots, (l_m, F_m)$ such that $|l_1|+|l_2| +
\cdots + |l_m| = k(n-k)$, where $|l_i|$ is the sum of the entries of $l_i$.

The function solves a Schubert problem by the Pieri homotopy algorithm. It
assumes all partitions except possibly the first two are simple (e.g. equal to
{1}). This algorithm uses homotopy continuation to track solutions of a simpler
problem to a general problem according to the specializations of the geometric
Pieri rule.

This algorithm is described in the paper: Huber, Sottile, and Sturmfels,
"Numerical Schubert Calculus",  J. Symb. Comp., 26 (1998), 767-788.

for instance, the Schubert problem {2,1}$^2$  {1}$^3$ in $Gr(3,6)$ has six
solutions. Consider the following instance given by random flags

+------------------------------------+
|i1 : k = 3;                         |
+------------------------------------+
|i2 : n = 6;                         |
+------------------------------------+
|i3 : SchPblm = {                    |
|         ({2,1}, random(CC^6,CC^6)),|
|         ({2,1}, random(CC^6,CC^6)),|
|         ({1}, random(CC^6,CC^6)),  |
|         ({1}, random(CC^6,CC^6)),  |
|         ({1}, random(CC^6,CC^6))   |
|         };                         |
+------------------------------------+

Its solutions to this instance

+-----------------------------------------------------------------------------+
|i4 : solveSimpleSchubert(SchPblm, k,n)                                       |
|                                                                             |
|o4 = {| .426402+.387024ii     -.767149+.88679ii  -.299645+.514617ii  |, |    |
|      | .350714+.0538475ii    -1.21057+.628777ii .141417+.670654ii   |  |    |
|      | -.00144609+.0615438ii -1.36249+.957226ii -.135443+.402697ii  |  |    |
|      | .236976-.167254ii     -.849462+.793055ii -.0797972+.62109ii  |  |    |
|      | .251567+.0963873ii    -.584053+.120158ii -.0811626+.616193ii |  |    |
|      | .16406+.140612ii      .147134+1.02782ii  .700057+.537171ii   |  |    |
|     ------------------------------------------------------------------------|
|     .0495704+.786748ii  1.06866+.233544ii -.050555-.348219ii  |, |          |
|     -.206829-.120362ii  1.77239+.496154ii -.495726-.478418ii  |  |          |
|     -.649096-.0452157ii 1.69103+.597783ii -.0259685-.564318ii |  |          |
|     -.288447+.394938ii  .928957+.172057ii -.307244-.389747ii  |  |          |
|     -.458603+.164307ii  1.24868+.022694ii -.109204-.543584ii  |  |          |
|     -.159612+.837151ii  .145965-.131173ii -.311686-.109522ii  |  |          |
|     ------------------------------------------------------------------------|
|     .786345+.0390369ii 2.04868+.698543ii -.111359-.0502477ii |, |           |
|     .850935+.235992ii  2.99936+1.61752ii -.249658-.107736ii  |  |           |
|     .583656+.186089ii  3.03503+1.65758ii -.036834-.234947ii  |  |           |
|     .739055-.656875ii  1.87368+.627178ii -.203199-.0546734ii |  |           |
|     .900963+.0645478ii 2.00882+.70537ii  -.0684508-.152856ii |  |           |
|     .488143-.479836ii  .601493-.588086ii .0472758+.081476ii  |  |           |
|     ------------------------------------------------------------------------|
|     .29604+.607542ii    -.426858-.110817ii   -.120347+.0333611ii  |, |      |
|     .0792163+.0318581ii -.264013-.679973ii   -.172278-.0120918ii  |  |      |
|     -.307005+.0794883ii -.488333-.457673ii   -.0312588-.143993ii  |  |      |
|     .0557081+.142424ii  -.514797-.16939ii    -.165842+.0348618ii  |  |      |
|     -.0644923+.200208ii -.00925758-.689311ii -.0470698-.0463538ii |  |      |
|     .0883581+.490683ii  -.344437+.638705ii   .151061+.124719ii    |  |      |
|     ------------------------------------------------------------------------|
|     .416853+.43068ii     -2.06356+1.47596ii -.555553+.0429811ii  |, |       |
|     .304534+.0650379ii   -3.3745+.909754ii  -.611663+.448933ii   |  |       |
|     -.0510879+.0812111ii -3.56377+1.40773ii -.494457-.0547096ii  |  |       |
|     .223864-.106046ii    -2.10608+1.35519ii -.600561+.286352ii   |  |       |
|     .204877+.130855ii    -1.91259+.304428ii -.579545+.13444ii    |  |       |
|     .170645+.202745ii    .219633+1.87171ii  -.00171043+.686346ii |  |       |
|     ------------------------------------------------------------------------|
|     .948004+.00971475ii .374969+.499562ii  -.059199+.251334ii |}            |
|     .954212+.376895ii   .636613+.574365ii  .116788+.149588ii  |             |
|     .720595+.326751ii   .530465+.763105ii  .073638+.0777737ii |             |
|     .96532-.698926ii    .256842+.425251ii  .0170751+.221298ii |             |
|     1.08396+.174263ii   .551008+.0768382ii .112884+.198469ii  |             |
|     .689695-.590038ii   .157157+.310587ii  .453721+.129014ii  |             |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+

Caveat
======

Need to input partitions together with flags.

See also
========

  * solveSchubertProblem -- uses
    Littlewood-Richardson homotopy algorithm to solve a Schubert problem

Ways to use solveSimpleSchubert :
=================================

  * "solveSimpleSchubert(List,ZZ,ZZ)"

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

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

WorkingPrecision -- option to raise the working precision to double double or quad double.
******************************************************************************************

Synopsis
========

  * Usage:
        LRtriple(...,WorkingPrecision=>ZZ)

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

The default working precision is double precision. Use WorkingPrecision=>1 for
double double precision. Use WorkingPrecision=>2 for quad double precision.

Functions with optional argument named WorkingPrecision :
=========================================================

  * "LRtriple(...,WorkingPrecision=>...)"

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

The object WorkingPrecision, is a symbol (Macaulay2Doc).

wrapTriplet -- Wraps a flag, system, and solutions into one string for phc -e.
******************************************************************************

Synopsis
========

  * Usage:
        w = wrapTriplet(f,p,s)
  * Inputs:
      * f, a string (Macaulay2Doc), represents the fixed flag
      * p, a string (Macaulay2Doc), represents a polynomial
        system
      * s, a string (Macaulay2Doc), solutions to the polynomial
        system
  * Outputs:
      * w, a string (Macaulay2Doc), suitable for input to cheater
        in phc -e

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

To pass the output of LRtriple to the LRcheater, the flag, the polynomial
system and its solutions are wrapped into one string.

Ways to use wrapTriplet :
=========================

  * "wrapTriplet(String,String,String)"

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

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