Numerical Schubert Calculus using Pieri homotopies with PHCv2.4.85

This directory was delivered with release 2 of PHCpack.
Release 2.1 has only minor updates to facilitate the connection with C.
The user can now request to compute only some solutions maps.

There are two parts in this library:
1) original Pieri homotopy algorithm : chain by chain
2) poset-based organization of the Pieri homotopies
The test programs are grouped per part.

Run "gprbuild pieri.gpr" to make all test programs.
On windows, type "gprbuild pieri.gpr -Xos=windows"
at the PowerShell prompt.
The "gprclean pieri.gpr" removes all files created by gprbuild.

-------------------------------------------------------------------------------
file name                        : short description
-------------------------------------------------------------------------------
pieri_trees                      : representation/creation of Pieri trees
pieri_trees_io                   : output of Pieri trees
pieri_root_counts                : produces a list of Pieri chains
symbolic_minor_equations         : symbolic form of equations in Pieri homotopy
numeric_minor_equations          : evaluated equations in the Pieri homotopy
determinantal_systems            : construction of equations from expansions
solve_pieri_leaves               : compute solutions at leaves of Pieri tree
specialization_of_planes         : set up the moving cycles
verification_with_determinants   : verifies the intersection conditions
pieri_continuation               : traces the paths defined by Pieri homotopy
plane_representations            : conversion between vector and matrix reps
pieri_deformations               : deforms down along the Pieri chains
ts_detsys                        : test on determinantal systems
ts_org_pieri                     : test on original Pieri homotopy algorithm
-------------------------------------------------------------------------------
localization_posets              : posets of top-bottom pivots
localization_posets_io           : output routines for localization posets
localization_poset_strings       : localization posets as strings
pieri_homotopies                 : construction of the Pieri homotopies
curves_into_grassmannian         : representation of the q-curves
curves_into_grassmannian_io      : output facilities for the q-curves
deformation_posets               : posets of solution planes
standard_matrix_inversion        : inverse of square matrix, standard doubles
dobldobl_matrix_inversion        : inverse of square matrix in double doubles
quaddobl_matrix_inversion        : inverse of square matrix in quad doubles
make_input_planes                : generators of input for Pieri algorithm
main_pieri_homotopies            : main procedure to run Pieri homotopies
main_quantum_pieri               : main procedure to run quantum Pieri
main_pieri_count                 : computes a Pieri root count
pieri_root_count                 : hypersurface quantum pieri root count
ts_canocurv                      : test localization patterns for q-curves
ts_posets                        : test on creation of the posets
ts_defpos                        : test on deformation posets
ts_matinv                        : test on matrix inversion
ts_pieri                         : test on the Pieri homotopies
ts_piroco                        : interactive test to call pieri_root_count
-------------------------------------------------------------------------------

Organization of the Pieri homotopies :

The original Pieri Homotopy Algorithm is organized in a chain-by-chain 
fashion, whereas the newer implementation uses posets.
The poset-oriented Pieri Homotopy Algorithm works better, but since most of
the basic packages is recycled, we can keep the original Pieri at low cost.
Both implementations have three distinct aspects:

1) combinatorial root count

A. The Pieri tree delivers chains of increasing sequences of brackets.
   Every chain models a sequence of nested subspaces, with lowering
   dimensions towards the leaves of the tree.  The set of input planes
   is partitioned into two nonempty sets and one set containing only the
   last input plane.  For each of the two sets a Pieri tree is constructed.
   A contribution to the root count is made by each pair of leaves that 
   satisfies Pieri's condition, for which a triple intersection of input
   plane yields a start solution.  The input to this combinatorial root
   count is a partition of the list of codimensions.  As output we obtain
   a list of pairs of leaves that satisfy Pieri's condition.

   packages: Pieri_Trees, Pieri_Trees_io, Pieri_Root_Counts

B. The poset-oriented Pieri homotopy algorithm only needs one concept,
   that of a localization pattern.  This pattern is determined by a
   couple of pivots indicating the topmost and bottommost nonzero entries.

   package: Localization_Posets

2) symbolic-numeric computation

   An intersection condition corresponds to the vanishing of all maximal
   minors of a matrix which is not necessarily square.
   Each matrix consists of two blocks, for coefficients and indeterminates.
   The Laplace expansion into minors respects this division and is
   written formally as a polynomial that is quadratic in brackets.
   To obtain a polynomial system we evaluate the minors, this is the
   numerical part in setting up the equations.
   The zeros in the localization pattern are determined by the positioning
   of the current node in the Pieri trees, but as far as the choice of the
   ones is concerned, we can divide by the largest element in each column to
   obtain a scaling and a numerically favorable representation of the equations.

   Only minor modifications were needed in the poset-oriented version.

   packages: Symbolic_Minor_Equations, Numeric_Minor_Equations
             Determinantal_Systems, Solve_Pieri_Leaves

3) deforming geometries

A. The pairs of chains that end in pairs of leaves that satisfy Pieri's
   condition form the backbone of the deformations in the Pieri homotopy
   algorithm.  The deformations start at the pairs of leaves with a triple
   intersection and move down in the Pieri trees until they reach the
   lowest node where the all intersection conditions are satisfied.
   While moving down we move to larger subspaces which admits the intersection
   with more input planes.  In the case where all codimensions equal one,
   at each node the current solution plane satisfies one more nontrivial
   intersection requirement with an additional input plane.

   packages: Pieri_Homotopies, Pieri_Continuation, Pieri_Deformations

B. The continuous analogue to the localization posets are deformation posets.
   These posets contain in their nodes the solution p-planes at that level.

   package: Deformation_Posets
