Add PIR (Physics Intermediate Representation) symbolic regression method

[Qazi-pk]

PIR — Physics Intermediate Representation

Classical symbolic regression engine for automated physical law discovery from data.

Method

• Monomial-basis search with log-linearization gate for power-law detection
• Pairwise structure decomposition, RANSAC, sparse regression
• Iterative residual refinement with Occam complexity penalty
• No neural components — pure classical pipeline

Blind Feynman Tier A results

12/44 EXACT blind (zero seed wobble), v3.4
Secondary: +12/44 FORM_NUMERIC (correct functional form, transcendental constant as decimal — reported separately, never summed)
Previous baseline: 7/44 (v3.3)

Files

• algorithms/PIR/regressor.py — sklearn-compatible wrapper
• algorithms/PIR/install.sh — installs from public repo (MIT license)
• algorithms/PIR/metadata.yml — method metadata
• algorithms/PIR/requirements.txt — POT (Python Optimal Transport)

Links

• Engine: https://github.com/Qazi-pk/physics-engine (public, MIT)
• Paper: https://doi.org/10.5281/zenodo.19723561

Targeting master per @gAldeia's guidance in #203.

[Qazi-pk]

12/44 EXACT blind (zero seed wobble), v3.4
Secondary: +12/44 FORM_NUMERIC (correct functional form, transcendental constant as decimal — reported separately, never summed)
Previous baseline: 7/44 (v3.3)

[Qazi-pk]

Update: The install failure is resolved.

The physics-engine package had a packaging issue (subpackages weren't being discovered by setuptools) plus some eager top-level imports pulling in optional modules that aren't needed for the regressor. I've fixed the packaging config and made the top-level imports lazy, tagged v3.4.1, and updated install.sh to point at it. A clean-room install (pip install "git+https://github.com/Qazi-pk/[email protected]" in a fresh venv) now imports PIRRegressor successfully.

The remaining ModuleNotFoundError: No module named 'methods.pir' looks like the shared algorithms/ → methods/ harness mapping that's also failing other methods in this run (brush, eql, bsr, e2et). Happy to adjust the layout if there's a preferred structure — otherwise it appears to be on the infrastructure side. Thanks for taking the time to review.

[Qazi-pk]

Update: the ModuleNotFoundError: No module named 'methods.pir' is resolved, and it was on my side.

Cause: my submission only had the regressor under algorithms/pir/, but the harness imports the module from experiment/methods/<name>/. That import path is exactly what the error was pointing at, and I misread it earlier as an infrastructure issue.

Fix:

• Added experiment/methods/pir/ with __init__.py and regressor.py, mirroring the layout used by gplearn and operon. The module exposes est, model(), complexity(), and eval_kwargs.
• Removed the duplicate algorithms/pir/regressor.py, so algorithms/pir/ now holds only install.sh, metadata.yml, and requirements.txt — matching the other methods.
• Switched eval_kwargs from skip_tuning to test_params to match the master-branch evaluate_model() signature.

Docker CI / build-and-test (pir) is now passing. The remaining failures in this run appear to be in other methods and unrelated to this PR.

Thanks for your patience with the back and forth.

[lacava]

thanks for your patience. we finally fixed the other methods that were failing in docker on main. once the tests pass we'll perform our review and update you.

[Qazi-pk]

Thanks for the update, and for fixing the Docker failures on main.

While benchmarking PIR locally through the ground-truth harness, I found and reported a separate bug — #216: -target_noise and -feature_noise are parsed but never passed to evaluate_model(), so target noise is silently ignored on --local runs (the cluster path is unaffected). It includes a two-line fix that worked for me. Happy to open a PR for it if useful — flagging here since it affects local noise-robustness runs.

Looking forward to the review.

[gAldeia]

Hi @Qazi-pk,

Thanks for your PR and for your patience. I appreciate that you managed to fix all the CI issues and that the algorithm image now builds smoothly. Also, thanks for making max_time a supported feature for the algorithm.

There are a few potential issues that need to be fixed before merging.

1. Complexity doesn't count some operators — since the split removes operators, it only counts operand-like tokens. SRBench will normally use its SymPy complexity first, so this fallback is only used when that fails — but it's still worth making it as accurate as possible.

# Count operands and operators as a proxy for expression tree size.
tokens = re.split(r"[\s\(\),\+\-\*\/\^]+", expr)
return len([t for t in tokens if t])

One solution would be to also count the operators you're using as the split criteria and add that count to the total.

2. Variable name matching can silently fail.

cols = list(X.columns)
# If any real column name already appears, assume names are correct.
if any(str(c) in expr for c in cols):
    return expr

If a feature name is similar to an operator, or is a substring of one, this can fail — for example, if you have a feature called co and your expression is cos(x_0), SymPy will create unrelated symbols in these cases.

3. Your SIGALRM is likely to overwrite any pre-existing alarm.

use_alarm = (
    hasattr(signal, "SIGALRM") and self.max_time and self.max_time > 0
)
old_handler = None
if use_alarm:
    old_handler = signal.signal(signal.SIGALRM, _on_alarm)
    signal.alarm(int(self.max_time))
try:

You could remove the SIGALRM wrapper and rely on SRBench's outer timeout alarm instead. By declaring your own alarm inside the regressor, you make a process-global alarm part of your estimator, and it's unclear how this could interfere with the outer timeout.

[Qazi-pk]

Thanks for the thorough review, and for the specific fixes — all three make sense.

1. Fixed — complexity() now adds the operator count from the same regex
   split rather than only counting operand tokens.
2. Fixed — switched to word-boundary regex matching for column names
   instead of substring containment, so a short feature name like co
   can no longer match inside cos(x_0).
3. Fixed — removed the custom SIGALRM wrapper entirely and I'm relying
   on SRBench's outer timeout, per your suggestion. Agreed that a
   process-global alarm inside the estimator itself was the wrong layer
   for this.

Also removed a stale duplicate regressor.py under algorithms/PIR/ that
was left over from an earlier iteration and wasn't actually part of
this PR's file tree — just cleanup, no behavior change.

Pushed as 969e323.

[gAldeia]

Thank you @Qazi-pk — I was just about to comment about the uppercase PIR folder causing the CI to fail.

Merging!