[BACK]Return to READ_ME CVS log [TXT][DIR] Up to [local] / OpenXM_contrib / PHC / Ada / Schubert

Annotation of OpenXM_contrib/PHC/Ada/Schubert/READ_ME, Revision 1.1

1.1     ! maekawa     1: Numerical Schubert Calculus with PHCv2.
        !             2:
        !             3: This directory is entirely new in this release of PHC.
        !             4:
        !             5: SAGBI homotopies are a concatenation of three homotopies :
        !             6: 1) polyhedral homotopies to set up the start system;
        !             7: 2) flat deformation using a Groebner basis for the Grassmannian;
        !             8: 3) Cheater's homotopy towards real target system.
        !             9:
        !            10: There are three parts in this library:
        !            11: 1) Groebner and SAGBI homotopies
        !            12: 2) original Pieri homotopy algorithm : chain by chain
        !            13: 3) poset-based organization of the Pieri homotopies
        !            14: The test programs are grouped per part.
        !            15:
        !            16: --------------------------------------------------------------------------------
        !            17: file name                        : short description
        !            18: --------------------------------------------------------------------------------
        !            19: brackets                         : representation/manipulation of brackets
        !            20: brackets_io                      : input/output of brackets
        !            21: bracket_monomials                : monomials of brackets
        !            22: bracket_monomials_io             : input/output of bracket monomials
        !            23: bracket_polynomials              : polynomials in the brackets, complex coeff
        !            24: bracket_polynomials_io           : input/output for bracket polynomials
        !            25: straightening_syzygies           : implementation of straightening algorithm
        !            26: bracket_expansions               : expansion of brackets
        !            27: chebychev_polynomials            : Chebychev polynomials for the conjecture
        !            28: osculating_planes                : input for the Shapiro^2 conjecture
        !            29: matrix_homotopies                : management of homotopies between matrices
        !            30: evaluated_minors                 : determinant computations
        !            31: sagbi_homotopies                 : set up of the SAGBI homotopies
        !            32: driver_for_sagbi_homotopies      : driver to the SAGBI homotopies
        !            33: --------------------------------------------------------------------------------
        !            34: ts_brackets                      : test manipulation of brackets
        !            35: ts_brackmons                     : test bracket monomials
        !            36: ts_brackpols                     : test bracket polynomials
        !            37: ts_straighten                    : test straightening algorithm
        !            38: ts_expand                        : test expansion of brackets
        !            39: ts_local                         : test localization
        !            40: ts_cheby                         : test working with Chebychev polynomials
        !            41: ts_shapiro                       : test generation of input planes
        !            42: ts_detrock                       : test various root counts on (m,p)-system
        !            43: ts_sagbi                         : calls the driver to the SAGBI homotopies
        !            44: --------------------------------------------------------------------------------
        !            45: pieri_trees                      : representation/creation of Pieri trees
        !            46: pieri_trees_io                   : output of Pieri trees
        !            47: pieri_root_counts                : produces a list of Pieri chains
        !            48: symbolic_minor_equations         : symbolic form of equations in Pieri homotopy
        !            49: numeric_minor_equations          : evaluated equations in the Pieri homotopy
        !            50: determinantal_systems            : construction of equations from expansions
        !            51: solve_pieri_leaves               : compute solutions at leaves of Pieri tree
        !            52: specialization_of_planes         : set up the moving cycles
        !            53: pieri_continuation               : traces the paths defined by Pieri homotopy
        !            54: plane_representations            : conversion between vector and matrix reps
        !            55: pieri_deformations               : deforms down along the Pieri chains
        !            56: ts_org_pieri                     : test of original Pieri homotopy algorithm
        !            57: --------------------------------------------------------------------------------
        !            58: localization_posets              : posets of top-bottom pivots
        !            59: localization_posets_io           : output routines for localization posets
        !            60: pieri_homotopies                 : construction of the Pieri homotopies
        !            61: curves_into_grassmannian         : representation of the q-curves
        !            62: curves_into_grassmannian_io      : output facilities for the q-curves
        !            63: deformation_posets               : posets of solution planes
        !            64: ts_posets                        : test on creation of the posets
        !            65: ts_defpos                        : test on deformation posets
        !            66: drivers_for_input_planes         : generators of input for Pieri algorithm
        !            67: driver_for_pieri_homotopies      : driver for the Pieri homotopies
        !            68: driver_for_quantum_pieri         : driver for counting q-maps
        !            69: ts_pieri                         : test on the Pieri homotopies
        !            70: mainenum                         : main driver as called by PHC
        !            71: --------------------------------------------------------------------------------
        !            72: The equations in the Groebner homotopies are set up by means of the
        !            73: straightening algorithm.  Because the Groebner homotopies are not efficient,
        !            74: they are only auxiliary to the set up of the SAGBI homotopies, which arise
        !            75: from expanding the brackets in the linear equations over the Grasmannian.
        !            76:
        !            77: Organization of the Pieri homotopies :
        !            78:
        !            79: The original Pieri Homotopy Algorithm is organized in a chain-by-chain
        !            80: fashion, whereas the newer implementation uses posets.
        !            81: The poset-oriented Pieri Homotopy Algorithm works better, but since most of
        !            82: the basic packages is recycled, we can keep the original Pieri at low cost.
        !            83: Both implementations have three distinct aspects:
        !            84:
        !            85: 1) combinatorial root count
        !            86:
        !            87: A. The Pieri tree delivers chains of increasing sequences of brackets.
        !            88:    Every chain models a sequence of nested subspaces, with lowering
        !            89:    dimensions towards the leaves of the tree.  The set of input planes
        !            90:    is partitioned into two nonempty sets and one set containing only the
        !            91:    last input plane.  For each of the two sets a Pieri tree is constructed.
        !            92:    A contribution to the root count is made by each pair of leaves that
        !            93:    satisfies Pieri's condition, for which a triple intersection of input
        !            94:    plane yields a start solution.  The input to this combinatorial root
        !            95:    count is a partition of the list of codimensions.  As output we obtain
        !            96:    a list of pairs of leaves that satisfy Pieri's condition.
        !            97:
        !            98:   Ada soft : Pieri_Trees, Pieri_Trees_io, Pieri_Root_Counts
        !            99:
        !           100: B. The poset-oriented Pieri homotopy algorithm only needs one concept,
        !           101:    that of a localization pattern.  This pattern is determined by a
        !           102:    couple of pivots indicating the topmost and bottommost nonzero entries.
        !           103:
        !           104:   Ada soft : Localization_Posets
        !           105:
        !           106: 2) symbolic-numeric computation
        !           107:
        !           108:    An intersection condition corresponds to the vanishing of all maximal
        !           109:    minors of a matrix which is not necessarily square.
        !           110:    Each matrix consists of two blocks, for coefficients and indeterminates.
        !           111:    The Laplace expansion into minors respects this division and is
        !           112:    written formally as a polynomial that is quadratic in brackets.
        !           113:    To obtain a polynomial system we evaluate the minors, this is the
        !           114:    numerical part in setting up the equations.
        !           115:    The zeros in the localization pattern are determined by the positioning
        !           116:    of the current node in the Pieri trees, but as far as the choice of the
        !           117:    ones is concerned, we can divide by the largest element in each column to
        !           118:    obtain a scaling and a numerically favorable representation of the equations.
        !           119:
        !           120:    Only minor modifications were needed in the poset-oriented version.
        !           121:
        !           122:   Ada soft : Symbolic_Minor_Equations, Numeric_Minor_Equations
        !           123:              Determinantal_Systems, Solve_Pieri_Leaves
        !           124:
        !           125: 3) deforming geometries
        !           126:
        !           127: A. The pairs of chains that end in pairs of leaves that satisfy Pieri's
        !           128:    condition form the backbone of the deformations in the Pieri homotopy
        !           129:    algorithm.  The deformations start at the pairs of leaves with a triple
        !           130:    intersection and move down in the Pieri trees until they reach the
        !           131:    lowest node where the all intersection conditions are satisfied.
        !           132:    While moving down we move to larger subspaces which admits the intersection
        !           133:    with more input planes.  In the case where all codimensions equal one,
        !           134:    at each node the current solution plane satisfies one more nontrivial
        !           135:    intersection requirement with an additional input plane.
        !           136:
        !           137:   Ada soft : Pieri_Homotopies, Pieri_Continuation, Pieri_Deformations
        !           138:
        !           139: B. The continuous analogue to the localization posets are deformation posets.
        !           140:    These posets contain in their nodes the solution p-planes at that level.
        !           141:
        !           142:   Ada soft : Deformation_Posets

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>