Skip to content

uber-polya v0.1.0 — Initial Release

Choose a tag to compare

View all tags
@agtm1199 agtm1199 released this 20 Feb 20:55
· 16 commits to main since this release
v0.1.0
df3d3ea

uber-polya v0.1.0 — Initial Release

Release date: 2026-02-18
License: Apache 2.0

Don't guess. Solve.

uber-polya is a Claude Skill that solves any problem with the right math tool, using George Polya's generic problem-solving method from How to Solve It (1945). Describe a real-world problem — business or personal — and uber-polya finds the mathematical structure hiding inside it, solves it with the right algorithm, verifies the answer, and delivers an actionable result.

The first math problem-solver skill for Claude Code and 25+ compatible platforms. Free, open-source, Apache 2.0.

Four Skills, One Pipeline

Skill Role What it does
/uber-polya Orchestrator Chains Model → Solve → Interpret as a single invocation with full-pipeline, fast-track, stop-after-model, and stop-after-solve modes
/uber-model Phase A: Understand & Plan Guides you from a vague real-world problem to a formal mathematical model through Socratic questioning
/uber-solve Phase B: Execute Selects the right algorithm, writes a verified Python solver, and produces a certified solution
/uber-interpret Phase C: Look Back Translates the mathematical solution into actionable, stakeholder-ready insights with visualizations 
/uber-polya (orchestrator)

/uber-model            /uber-solve             /uber-interpret
"What IS the           "What is the            "What does it
 problem?"              ANSWER?"                MEAN?"

 Real-world    -->     Formal Model    -->     Verified       -->    Actionable
 problem               (math)                 Solution              Insight

Knowledge Base

139 algorithms, 43 structures, 17 heuristics, 15 solver libraries — curated, cross-referenced, and organized for rapid problem-solving.

Catalog Entries Details
Polya's Heuristics 17 Socratic questions: draw a figure, introduce notation, work backwards, decompose, find analogies, and more
Structure Catalog 43 across 10 domains Graphs, trees, matchings, set systems, LPs, ILPs, sequences, recurrences, Boolean formulas, convex programs, QPs, random variables, hypothesis tests, regression models, Bayesian models, experimental designs
Problem Classification Decision tree + pattern table Rapid matching from problem description to mathematical structure
Common Mistakes 16 anti-patterns Modeling (M1–M10), solving (S1–S6), interpretation (I1–I6)
Algorithm Catalog (Discrete/Continuous) 94 algorithms Graph, combinatorial, ILP/LP, SAT/SMT, number theory, DP, BFGS, gradient descent, SQP, interior point, cvxpy DCP
Algorithm Catalog (Statistics) 45 algorithms Hypothesis tests, regression, Bayesian methods, estimation, resampling
Solver Ecosystem 15 Python libraries NetworkX, PuLP, Z3, SymPy, SciPy, OR-Tools, cvxpy, statsmodels, scikit-learn, PyMC, pingouin, lifelines, and more
Model Templates 5 patterns Fill-in-the-blank templates for assignment, scheduling, routing, selection, dependency ordering
Solving Protocols 8 workflows Domain-specific solving procedures for graph, ILP/LP, SAT/SMT, counting, proof, number theory, DP, continuous optimization
Optimization Hardening Phase 4 guide Performance tuning and production hardening for solvers
Interpretation Patterns 11 pattern groups Domain-specific math-to-reality translation for discrete, continuous, and statistical results
Visualization Guide 20+ chart types Gantt, network, heatmap, bar, sensitivity, Pareto, timeline, QQ, regression, residual, forest, posterior, and more

Domains Covered

Domain Algorithms Structures Solver Libraries
Discrete Mathematics 86 32 8 (NetworkX, PuLP, Z3, SymPy, SciPy, OR-Tools, and more)
Continuous Optimization 8 5 cvxpy, SciPy
Statistical Inference 45 6 6 (scipy.stats, statsmodels, scikit-learn, PyMC, pingouin, lifelines)

All reference files carry Scope tags for multi-domain awareness and include cross-reference indexes linking structures → algorithms → solvers → interpretation → visualization.

16 Worked Examples

Everyday Problems (10)

Example Problem Algorithm
Shift Scheduling Schedule 8 nurses across 3 shifts over 7 days ILP (PuLP/CBC)
Budget Optimization Select projects to maximize ROI under budget 0/1 Knapsack ILP
Fair Rent Split rent fairly among 3 roommates Hungarian + envy-free adjustment
Route Planning Shortest delivery route across 8 stops Held-Karp DP (exact TSP)
Project Prioritization Rank 8 features by weighted criteria MCDA weighted scoring
Study Schedule Conflict-free study timetable for 6 subjects Graph coloring (NetworkX)
Meal Planning Plan 7 dinners minimizing cost, meeting nutrition targets ILP (PuLP/CBC)
Team Assignment Assign 6 developers to 6 projects Hungarian algorithm (SciPy)
Break-Even Analysis Find break-even quantity for product launch Symbolic algebra (SymPy)
Event Seating Seat 12 wedding guests at 3 tables with constraints ILP (PuLP/CBC)

Technical Showcases (6)

Example Domain Algorithm
Milking Cows Interval merging Sort + sweep, O(N log N)
Inspector Assignment Bipartite ILP PuLP/CBC solver
Portfolio Optimization Convex QP cvxpy (Markowitz efficient frontier)
Tournament Hamiltonian Graph proof Induction + Z3 verification
A/B Testing Statistical inference z-test + Bayesian + bootstrap + power analysis
Cafe Tips Statistical inference t-test + Mann-Whitney + permutation + bootstrap + Bayesian

Every example includes a README, Python solver script, sample input/output, independent verify() function, and visualization.

Installation

git clone https://github.com/agtm1199/uber-polya.git
cd uber-polya
bash install.sh

The installer asks whether to install globally (~/.claude/skills/) or locally (./.claude/skills/). Works on macOS and Linux.

Python Dependencies

pip install networkx pulp z3-solver sympy scipy matplotlib numpy cvxpy statsmodels

Cross-Platform Compatibility

uber-polya uses the Agent Skills open standard and works on any platform that supports it:

  • Claude Code (Anthropic)
  • OpenAI Codex CLI
  • Cursor
  • GitHub Copilot
  • Mistral Vibe
  • And 25+ more

Documentation

  • The Manifesto — Why every problem is a math problem
  • Architecture — Polya's method mapped to the skill trilogy, knowledge base design, expansion architecture
  • Getting Started — Step-by-step walkthrough with the exam scheduling problem
  • Creating Skills — How to build new skills following the uber-polya patterns
  • Contributing — Add algorithms, domains, or examples
  • Usage Guide — Full HTML guide with problem gallery, knowledge base reference, and FAQ

Walkthrough Pages

Design Principles

  1. Socratic, not didactic. Asks questions that could have occurred to you. Never lectures.
  2. Verify everything. Every solution includes independent verification.
  3. Right tool for the job. Algorithm selection based on problem class and instance size.
  4. Audience adaptation. Results adapted for technical, decision-maker, or general audiences.
  5. Knowledge transfer. Every problem teaches a reusable modeling pattern.
  6. Modular expansion. New domains plug in without changing the core workflow.

Technical Details

  • Python 3.10+ required for solver scripts
  • dataclass(frozen=True) for immutable problem instances
  • dataclass for mutable solution objects
  • time.perf_counter() timing on all solvers
  • Independent verify() function on every solver (must not share logic with solve())
  • #!/usr/bin/env python3 shebang and module docstrings on all scripts
  • Type hints on all function signatures
  • from __future__ import annotations at top of all modules
  • Structured artifact schemas: Formal Model, Solution Report, Interpretation Report
  • Self-evaluation checklists after every phase gate

Expansion Roadmap

Domain Status
Discrete Mathematics Shipped
Continuous Optimization Shipped
Statistical Inference Shipped
Game Theory Planned
Machine Learning Planned
Simulation Planned
Time Series Planned
Decision Analysis Planned

New domains plug in as reference files without changing the core Polya workflow. See CONTRIBUTING.md.

Links

Assets 2
Loading