ANN: Rubi fully ported to Python

[Upabjojr]

Hi, I have created the Python port of Rubi:

https://github.com/Upabjojr/rubi-integrate

This is already available on PyPI:

https://pypi.org/project/rubi-integrate/

from sympy import Symbol, sin, exp
from rubi_integrate import rubi_integrate

x = Symbol('x')

rubi_integrate(1/x, x)            # log(x)
rubi_integrate(x**2, x)           # x**3/3
rubi_integrate(sin(x)*x, x)       # -x*cos(x) + sin(x)
rubi_integrate(exp(x**2), x)      # sqrt(pi)*erfi(x)/2

It can also return the matched rules:

result, matched = rubi_integrate(exp(x)*sin(x**2 + x), x, return_matched_rules=True)
# matched == [(result, [
#     ('4.7.7 F^(c (a+b x)) trig(d+e x)^n', 44),
#     ('2.3 Miscellaneous exponentials', 43),
#     ('2.3 Miscellaneous exponentials', 42),
#     ('2.3 Miscellaneous exponentials', 11),
#     ... ])]

Unfortunately it's not 100% compatible with the way rules are solved in Mathematica, but I tried to get as close as possible.

It currently requires the development build of SymPy (1.15+) which has not yet been released.

[stblake]

That's unreal! FYI, most, if not all of the Rubi rules will run happily in Mathilda: https://github.com/stblake/mathilda Sam

…

On Thu, Aug 6, 2026 at 8:36 PM Francesco Bonazzi ***@***.***> wrote: *Upabjojr* created an issue (RuleBasedIntegration/Rubi#62) <#62> Hi, I have created the Python port of Rubi: https://github.com/Upabjojr/rubi-integrate This is already available on PyPI: https://pypi.org/project/rubi-integrate/ from sympy import Symbol, sin, expfrom rubi_integrate import rubi_integrate x = Symbol('x') rubi_integrate(1/x, x) # log(x)rubi_integrate(x**2, x) # x**3/3rubi_integrate(sin(x)*x, x) # -x*cos(x) + sin(x)rubi_integrate(exp(x**2), x) # sqrt(pi)*erfi(x)/2 It can also return the matched rules: result, matched = rubi_integrate(exp(x)*sin(x**2 + x), x, return_matched_rules=True)# matched == [(result, [# ('4.7.7 F^(c (a+b x)) trig(d+e x)^n', 44),# ('2.3 Miscellaneous exponentials', 43),# ('2.3 Miscellaneous exponentials', 42),# ('2.3 Miscellaneous exponentials', 11),# ... ])] Unfortunately it's not 100% compatible with the way rules are solved in Mathematica, but I tried to get as close as possible. It currently *requires* the *development build of SymPy* (1.15+) which has *not yet been released*. — Reply to this email directly, view it on GitHub <#62?email_source=notifications&email_token=AB5ALCRG6HWQM2AY4SHFC4T5IRNRNA5CNFSL4Z3JMQ5C6L3HNF2C22DVMIXUS43TOVSS6NJQHAYDENRYGAZTLJTSMVQXG33OVJZXKYTTMNZGSYTFMSSWK5TFNZ2KYZTPN52GK4S7MNWGSY3L>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AB5ALCWSWAMFK2BM2MIR47L5IRNRNAVCNFSNUABFKJSXA33TNF2G64TZHMYTGNJUGM2DQMBTHNEXG43VMU5TKMBYGAZDMOBQGM22C5QC> . Triage notifications, keep track of coding agent tasks and review pull requests on the go with GitHub Mobile for iOS <https://github.com/notifications/mobile/ios/AB5ALCU6C52FRJUEW3XCGUT5IRNRNA5CNFSL4Z3JMQ5C6L3HNF2C22DVMIXUS43TOVSS6NJQHAYDENRYGAZTLJTSMVQXG33OVJZXKYTTMNZGSYTFMSSWK5TFNZ2KUZTPN52GK4S7NFXXG> and Android <https://github.com/notifications/mobile/android/AB5ALCRQHTM3HK47KBYW7TL5IRNRNA5CNFSL4Z3JMQ5C6L3HNF2C22DVMIXUS43TOVSS6NJQHAYDENRYGAZTLJTSMVQXG33OVJZXKYTTMNZGSYTFMSSWK5TFNZ2K4ZTPN52GK4S7MFXGI4TPNFSA>. Download it today! You are receiving this because you are subscribed to this thread.Message ID: ***@***.***>

[Upabjojr]

Nice, didn't know about Mathilda.

My current issue is a 30-40 seconds wait time the first time rules are loaded. Rule take about 1.3 GB of RAM memory when loaded in Python.

[axkr]

Wow, everywhere progress in integrating Rubi in the tool chain.

Also in the latest Symja Java project commits:

• https://github.com/axkr/symja_android_library
• https://github.com/axkr/symja_android_library/wiki/Porting-Rubi-Integration-rules-to-Symja

I'm still using version 4.16.0.
Did someone succeed in using full 4.17.3 version?

[stblake]

It's not a primary goal of Mathilda to get Rubi running, but I'm sure the pattern matcher is capable of running the Rubi rules.

[stblake]

Mathilda has the following rule table, based on the CRC Math tables:

https://github.com/stblake/mathilda/blob/main/src/internal/CRCMathTablesIntegrals.m

[Upabjojr]

What algorithm does Mathilda use to apply multiple pattern matchings?

I have created OmniMatch by forking MatchPy, to support efficient many-to-one matching with associative and commutative node awareness.

[stblake]

Mathilda has, more or less, a complete implementation of the pattern matcher in Mathematica. I'll write an advanced tutorial on pattern matching and put it on: https://stblake.github.io/mathilda/

…

On Fri, Aug 7, 2026 at 7:50 PM Francesco Bonazzi ***@***.***> wrote: *Upabjojr* left a comment (RuleBasedIntegration/Rubi#62) <#62 (comment)> What algorithm does Mathilda use to apply multiple pattern matchings? I have created OmniMatch by forking MatchPy, to support efficient many-to-one matching with associative and commutative node awareness. — Reply to this email directly, view it on GitHub <#62?email_source=notifications&email_token=AB5ALCTVQ5TFIRCRULEAHCT5IWQ5TA5CNFSNUABFM5UWIORPF5TWS5BNNB2WEL2JONZXKZKDN5WW2ZLOOQXTKMRRGU2TAMZXGEY2M4TFMFZW63VHMNXW23LFNZ2KKZLWMVXHJLDGN5XXIZLSL5RWY2LDNM#issuecomment-5215503711>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AB5ALCSCWOFJ24K6V3E7X3T5IWQ5TAVCNFSNUABFKJSXA33TNF2G64TZHMYTGNJUGM2DQMBTHNEXG43VMU5TKMBYGAZDMOBQGM22C5QC> . Triage notifications, keep track of coding agent tasks and review pull requests on the go with GitHub Mobile for iOS <https://github.com/notifications/mobile/ios/AB5ALCTZDHMFYVI4HTR7ZDD5IWQ5TA5CNFSNUABFM5UWIORPF5TWS5BNNB2WEL2JONZXKZKDN5WW2ZLOOQXTKMRRGU2TAMZXGEY2M4TFMFZW63VHMNXW23LFNZ2KKZLWMVXHJKTGN5XXIZLSL5UW64Y> and Android <https://github.com/notifications/mobile/android/AB5ALCQRCDF2UPRTT5RY43T5IWQ5TA5CNFSNUABFM5UWIORPF5TWS5BNNB2WEL2JONZXKZKDN5WW2ZLOOQXTKMRRGU2TAMZXGEY2M4TFMFZW63VHMNXW23LFNZ2KKZLWMVXHJLTGN5XXIZLSL5QW4ZDSN5UWI>. Download it today! You are receiving this because you commented.Message ID: ***@***.***>

[ValentinHirschi]

And also note that the complete set of Rubi rules are now available in the Rust CAS Symbolica (with full-fledged python API, source-available, and free on one core for academics)!

https://github.com/symbolica-dev/symbolica-integrate

and running even faster than in Mathematica.

[Upabjojr]

What kind of algorithm do you use to speed up pattern matching resolution?

I mostly relied on this: https://arxiv.org/abs/1710.00077

[ValentinHirschi]

What kind of algorithm do you use to speed up pattern matching resolution?

I mostly relied on this: https://arxiv.org/abs/1710.00077

This is work done by Symbolica's author, together with Codex for the tedious work of converting the patterns to Symbolica syntax and features.
As far as pattern matching efficiency goes, my understanding of how Symbolica does things only goes as far as saying it's efficient low-level binary representation of the expression allowing for fast conditional expression traversal in Rust, with early termination clauses as soon as matches are proven impossible.

[Upabjojr]

What kind of algorithm do you use to speed up pattern matching resolution?
I mostly relied on this: https://arxiv.org/abs/1710.00077

This is work done by Symbolica's author, together with Codex for the tedious work of converting the patterns to Symbolica syntax and features. As far as pattern matching efficiency goes, my understanding of how Symbolica does things only goes as far as saying it's efficient low-level binary representation of the expression allowing for fast conditional expression traversal in Rust, with early termination clauses as soon as matches are proven impossible.

So it keeps looping over all patterns? Does it not attempt at merging the pattern into a single data structure to perform the search all at once?

[ValentinHirschi]

@Upabjojr No, each replacement rule is applied and processed in turn; and I believe that after each hit you must necessarily start over from the beginning of the list.
And this order actually plays an important role in the way Rubi works, for both efficiency and to avoid infinite cycles.

Notice, however, that especially in the Rust API, Symbolica allows for very complicated combinations of patterns, and with arbitrary closures. Also, because a match statement using a pattern yields an iterator, you can in principle easily steer the stepping through them in any way you wish (when there are multiple matches).

You can find more info in the blog from Symbolica's author on his implementation of Rubi:
https://symbolica.io/posts/symbolic_integration/

[Upabjojr]

Yes, I had problems with the rule order. When loading the rules, I blend all pattern expression trees into a unique search data structure (a generalized discrimination net), leaves are labeled with a reference to the pattern.

Unfortunately this makes the matching order unpredictable, I have compensated the change in rule matching order by wrapping the matcher with another algorithm that extracts multiple matches and picks the highest priority one.

This merging of patterns has the shortcoming of taking about 30 seconds to load all rules, but once loaded the matcher is extremely fast even in a slow programmnig language like Python.

One downside... my code take 1.3 gigabytes of memory once loaded, blending the patterns together into a single matching data structure is resource demanding.

Maybe I should try to translate Python into Rust as well 😀

[ValentinHirschi]

@Upabjojr Yeah, when using the Rubi integration module in Symbolica, you also have this one-off load time of a couple seconds.

By the way did you give it a shot? Does it not meet your usecase already?

[Upabjojr]

My purpose was to remain within the Python programming language.