Modernizing PHCpack through phcpy

Technical Summary: Modernizing PHCpack through phcpy

Problem Statement
PHCpack is a comprehensive software package designed to solve systems of polynomial equations in several variables using numerical homotopy continuation methods. While powerful, the original PHCpack (written in Ada) operates primarily as a file-oriented, menu-driven executable (phc). This architecture presents significant usability and integration challenges: users must navigate menus, manage intermediate files for input and output, and lack direct programmatic access to the underlying algorithms. Furthermore, the original codebase suffers from a lack of adequate user documentation, obscuring many of its features. The mathematical challenge addressed remains the computation of all isolated complex solutions and positive-dimensional irreducible solution sets (represented as witness sets or monomial maps) for polynomial systems, often requiring high-precision arithmetic to handle singularities and multiplicity.

Methodology
The paper describes the development of phcpy, a Python interface that modernizes PHCpack by replacing the file-based workflow with persistent objects and an interpreter interface. The methodology relies on a specific software architecture:

1. Interface Layering: phcpy does not call the phc executable directly. Instead, it builds upon the existing C interface (PHClib) to the Ada source code of PHCpack.
2. Design Patterns: The architecture employs the Façade pattern to provide a unified, modern interface to the legacy Ada system. The internal mechanism uses the Chain of Responsibility pattern (via the Ada procedure use_c2phc.adb) to route requests to specific packages within PHCpack based on a job number.
3. Implementation: The Python bindings are implemented in a single C file (phcpy2c.c) which wraps the C interface function _ada_use_c2phc. This allows Python to interact with the C/Ada backend without duplicating data structures for polynomials and solutions.
4. Functionality: The interface exposes the "blackbox" solver, mixed-volume calculators, path trackers, and deflation methods directly within the Python shell or scripts. Crucially, it introduces generator functions for path trackers, allowing users to iterate through solution paths point-by-point rather than waiting for a complete file output.

Key Contributions

• Python Interface (phcpy): A fully functional Python package (version 0.1.5 at the time of writing) that allows users to define polynomial systems as lists of strings and solve them directly in the Python environment.
• Persistent Objects: The replacement of intermediate files with persistent Python objects streamlines the workflow, enabling the use of Python generators to track solution paths dynamically.
• Documentation and Refactoring: The project refactors PHCpack's functionality into Python modules, generating extensive, beautiful documentation via Sphinx, thereby addressing the original package's documentation deficit.
• Reproducibility: The interface facilitates automated regression testing of computational results via Python scripts, enhancing the reproducibility of published numerical algebraic geometry results.
• Precision Support: The interface supports standard double, double-double, quad-double, and arbitrary multiprecision arithmetic, allowing for detailed investigation of solution path properties.

Results and Capabilities
The paper demonstrates that phcpy successfully replicates the core capabilities of PHCpack, including:

• Solving systems of polynomial equations and returning solutions with error metrics (err, rco, res).
• Calculating the mixed volume to predict the number of isolated solutions.
• Handling positive-dimensional solution sets via witness sets (random linear equations) and monomial maps for binomial systems.
• Providing a suite of modules including solver, examples (for benchmarking), families, phcmaps, phcsols, phcsets, phcwulf, and schubert.
• Achieving a high code quality rating (9.73/10) via Pylint analysis.

Significance and Scope
The paper positions phcpy as a modernization effort rather than a replacement for the core PHCpack algorithms. Its significance lies in bridging the gap between legacy numerical algebraic geometry software and modern scientific computing workflows. By leveraging the growing popularity of Python, the interface makes PHCpack's advanced homotopy continuation methods more accessible, scriptable, and integrable with other scientific tools. The authors note that while other interfaces exist (for Maple, MATLAB, Macaulay2), phcpy offers unique advantages through its object-oriented design and generator-based path tracking. The work is presented as a beta-stage tool (as of 2013/2014) intended to encourage community contributions and further development, supported by the National Science Foundation.