← Executive Summary • Pillar 05: Sovereign UX & Neuro-Symbolic Synthesis
ACM Journal Publication & Applied Mathematics

Computational Mathematics &
Pólya Enumeration Algorithms

Numerical algorithm design for exact combinatorial counting under finite group action. Published in the ACM Journal of Experimental Algorithmics / TOMS (DOI: 10.1145/2955094).

Graph networks, matching topologies, and numerical optimization manifolds
GRAPH → MATCH → OPTIMIZE Combinatorial Optimization, Finite Group Actions & Provable Numerical Convergence
Executive TL;DR

Applied Mathematics & Optimization

View 5 Pillars →
🎯 Business Context

Rigorous mathematical optimization and numerical algorithms for scientific computing and deterministic AI.

⚡ Technical Hurdle

Non-convex parameter spaces, coordinate descent convergence guarantees, and floating-point roundoff error.

🏆 Deliverable & Impact

Provable convergence algorithms, Fortran-to-Python test frameworks (Fortpy), and published computational benchmarks.

1 ACM Paper
ACM JEA / TOMS Publication
DOI: 10.1145/2955094
100% Unit Tested
Fortpy Automated Validation Suite
Verified on Finite Group Orders
2 Core Engines
Python & Fortran 90 Implementations
Dual High-Level & High-Performance Cores
0 Limits
Permutation Group Symmetries
Dihedral, Permutation & Crystallographic Groups
📜 Peer-Reviewed ACM Journal Publication
GitHub Repo ACM Digital Library (DOI: 10.1145/2955094) ↗

"Numerical Algorithm for Pólya Enumeration Theorem"

Authors: Conrad W. Rosenbrock, Wiley S. Morgan, Gus L. W. Hart, Stefano Curtarolo, Rodney W. Forcade.
Journal: ACM Journal of Experimental Algorithmics (JEA) / TOMS, Vol. 21, 2016.

Abstract & Innovation: Presents a general numerical algorithm for calculating the number of unique colorings of a finite set under the action of a finite group, based on the Pólya Enumeration Theorem. This method eliminates the need for manual cycle index polynomial derivation, enabling automated exploration of derivative superstructures and configurational freedom in materials science.
Numerical Pólya Enumeration Pipeline Architecture
Inspect Algorithm Architecture
Algorithm Pipeline • ACM JEA 2016

Numerical Cycle Index Formulation & Monomial Extractor

Translating finite group generators into exact symmetry-reduced coloring counts without symbolic polynomial expansion bottlenecks.

Read Published Article in ACM Digital Library (DOI: 10.1145/2955094) ↗

Technical Contributions & Algorithmic Innovations

Key mathematical breakthroughs and software engineering achievements published in the ACM paper and open-source codebase:

  • ✓
    Numerical Cycle Index Formulation: Formulated general numerical algorithm that calculates cycle index polynomials directly from permutation generators in cycle notation.
  • ✓
    Elimination of Symbolic Algebra: Bypassed symbolic polynomial expansions and computer algebra system (CAS) dependencies using multi-index tensor dynamic programming.
  • ✓
    High-Performance Fortran 90 Core: Authored Fortran 90 core module with zero dynamic heap allocations in inner loops for massive-throughput materials enumeration pipelines.
  • ✓
    Dual Python / Fortran Architecture: Created accessible high-level Python CLI (polya.py) alongside optimized Fortran 90 engine with identical numerical accuracy.
  • ✓
    Fortpy Automated Validation: Built 100% unit-test coverage suite executed via fortpy validating hundreds of permutation group orders and colorings.
  • ✓
    Peer-Reviewed ACM JEA / TOMS Publication: Co-authored and published in ACM Journal of Experimental Algorithmics (2016), cited in crystallography and discrete mathematics.

Group Symmetry Generators (CLI)

Input group generators are specified in cycle notation (e.g. Dihedral group $ of the square). The algorithm constructs the cycle index polynomial dynamically and evaluates polynomial coefficients.

polya/python/polya.py
# Example: Counting unique 2-colorings of square corners with 2 corners per color
./polya.py 2 2 -generators generators.in.paper

# Output: Number of symmetrically unique colorings
Unique Colorings Count: 2

High-Performance Fortran 90 Core

Accompanied by a 100% unit-tested Fortran 90 core module for ultra-fast evaluation in large-scale cluster expansion and thermodynamic enumeration pipelines.

polya/fortran/polya_driver.f90
use polya_core, only: polyas_theorem
integer :: counts, colors(2) = [2, 2]

! Fast numerical evaluation with zero heap allocations
call polyas_theorem(group_gens, colors, counts)
write(*,*) "Unique configurations: ", counts